int main(int argc, char ** argv) { DIR * cleandir; struct dirent * curfile; unsigned long long curval; setlimits(); if(argc!=3) usage(); matchlimit = atoi(argv[1]); if(matchlimit == 0) usage(); cleandir = opendir(argv[2]); if(cleandir == NULL) { perror(argv[2]); return 3; } while(curfile = readdir(cleandir)) { if(curfile->d_name[0] == '.') continue; curval = load_rules(curfile->d_name); if(curval < matchlimit) printf("%s %lld\n", curfile->d_name, curval); } return 0; }
int pa__init(pa_module*m) { pa_modargs *ma = NULL; struct userdata *u; pa_bool_t restore_device = TRUE, restore_volume = TRUE; pa_assert(m); if (!(ma = pa_modargs_new(m->argument, valid_modargs))) { pa_log("Failed to parse module arguments"); goto fail; } u = pa_xnew(struct userdata, 1); u->core = m->core; u->hashmap = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); u->table_file = pa_xstrdup(pa_modargs_get_value(ma, "table", NULL)); u->modified = FALSE; u->subscription = NULL; u->sink_input_new_hook_slot = u->sink_input_fixate_hook_slot = u->source_output_new_hook_slot = NULL; u->save_time_event = NULL; m->userdata = u; if (pa_modargs_get_value_boolean(ma, "restore_device", &restore_device) < 0 || pa_modargs_get_value_boolean(ma, "restore_volume", &restore_volume) < 0) { pa_log("restore_volume= and restore_device= expect boolean arguments"); goto fail; } if (!(restore_device || restore_volume)) { pa_log("Both restrong the volume and restoring the device are disabled. There's no point in using this module at all then, failing."); goto fail; } if (load_rules(u) < 0) goto fail; u->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_SINK_INPUT|PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, subscribe_callback, u); if (restore_device) { u->sink_input_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], (pa_hook_cb_t) sink_input_new_hook_callback, u); u->source_output_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], (pa_hook_cb_t) source_output_new_hook_callback, u); } if (restore_volume) u->sink_input_fixate_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], (pa_hook_cb_t) sink_input_fixate_hook_callback, u); pa_modargs_free(ma); return 0; fail: pa__done(m); if (ma) pa_modargs_free(ma); return -1; }
Datum connection_reload_config(PG_FUNCTION_ARGS) { elog(DEBUG1, "reloading connection rules from configuration file"); load_rules(); elog(DEBUG1, "connection rules reloaded : %d rules found", rules->n_rules); PG_RETURN_VOID(); }
/* * Probably the most important part - allocates the shared segment * with space for all the rules (and process info), loads the rules * from file and performs all the initialization necessary. */ static void pg_limits_shmem_startup() { bool found = FALSE; char *segment = NULL; if (prev_shmem_startup_hook) prev_shmem_startup_hook(); /* Create or attach to the shared memory state (for the rules). */ LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); segment = ShmemInitStruct(SEGMENT_NAME, SEGMENT_SIZE, &found); #if (PG_VERSION_NUM < 90000) /* since 9.0, it always throws an error */ if (segment == NULL) elog(ERROR, "a call to ShmemInitStruct failed (connection_limits)"); #endif /* rules are placed first, then the cached backend info */ rules = (rules_t*)(segment); backends = (BackendInfo*)(segment + offsetof(rules_t, rules) + sizeof(rule_t) * MAX_RULES); elog(DEBUG1, "initializing segment with connection limit rules (size: %lu B)", SEGMENT_SIZE); /* Perform initialization if this is the first time we see the segment. */ if (! found) { /* * make sure the segment is empty (no rules, ...) * * load_rules() resets only the part where the rules are stored, * and we need to reset the whole segment (including backend info) */ memset(rules, 0, SEGMENT_SIZE); load_rules(); elog(DEBUG1, "shared memory segment successfully created, %d rules loaded", rules->n_rules); } LWLockRelease(AddinShmemInitLock); }
Keyswitch::Keyswitch(XKeyboard *keyboard, QWidget *parent) : QLabel(parent) { keys=keyboard; QSettings * antico = new QSettings(QCoreApplication::applicationDirPath() + "/antico.cfg", QSettings::IniFormat, this); antico->beginGroup("Style"); map_path = antico->value("path").toString()+"/language/"; antico->endGroup(); //Style xkbConf = X11tools::loadXKBconf(); if (xkbConf->status!=DONT_USE_XKB) { load_rules(); qDebug()<<"XKB status : " <<xkbConf->status; if (xkbConf->status==USE_XKB) set_xkb(); init(); if (groupeName.count()>1 || xkbConf->showSingle) { draw_icon(); createMenu(); } } }
bool http_server::load_hosts(const xmlconf& conf, const general_conf& general_conf) { const char* host; size_t hostlen; const char* value; size_t len; bool b; for (unsigned i = 0; conf.get_child(i, host, hostlen, "config", "hosts", NULL); i++) { bool def; if (!conf.get_value(def, "config", "hosts", host, "default", NULL)) { def = false; } const char* document_root; size_t document_root_len; if (!conf.get_value(document_root, document_root_len, "config", "hosts", host, "document_root", NULL)) { logger::instance().log(logger::LOG_ERROR, "Empty document root for host %s.", host); return false; } else { if (document_root[document_root_len - 1] == '/') { document_root_len--; } } bool log_requests; char dir[PATH_MAX + 1]; const char* filename = NULL; const char* log_format = general_conf.log_format; size_t bufsize = general_conf.log_buffer_size; size_t access_log_max_file_size = general_conf.access_log_max_file_size; if (general_conf.log_requests == TRIBOOL_FALSE) { log_requests = false; } else { if (conf.get_value(b, "config", "hosts", host, "log_requests", NULL)) { log_requests = b; } else { log_requests = (general_conf.log_requests == TRIBOOL_TRUE) ? true : false; } if (log_requests) { if (!conf.get_value(value, len, "config", "hosts", host, "access_log", NULL)) { logger::instance().log(logger::LOG_ERROR, "Empty access log for host %s.", host); return false; } if (!get_dirname_basename(value, len, dir, filename)) { return false; } if (conf.get_value(value, len, "config", "hosts", host, "log_format", NULL)) { log_format = value; } if (conf.get_value(bufsize, "config", "hosts", host, "log_buffer_size", NULL)) { if (bufsize > 1024) { bufsize = 1024; logger::instance().log(logger::LOG_INFO, "Log buffer size too big, set to %u KB.", bufsize); } } if (conf.get_value(access_log_max_file_size, "config", "hosts", host, "access_log_max_file_size", NULL)) { if (access_log_max_file_size < 32) { access_log_max_file_size = 32; logger::instance().log(logger::LOG_INFO, "Access log maximum file size too small, set to %u KB.", access_log_max_file_size); } else if (access_log_max_file_size > 4 * 1024 * 1024) { access_log_max_file_size = 4 * 1024 * 1024; logger::instance().log(logger::LOG_INFO, "Access log maximum file size too big, set to %u KB.", access_log_max_file_size); } } } } bool have_dirlisting; if (general_conf.have_dirlisting == TRIBOOL_FALSE) { have_dirlisting = false; } else { if (conf.get_value(b, "config", "hosts", host, "directory_listing", NULL)) { have_dirlisting = b; } else { have_dirlisting = (general_conf.have_dirlisting == TRIBOOL_TRUE) ? true : false; } } virtual_hosts::vhost* vhost; if ((vhost = _M_vhosts.add(host, hostlen, document_root, document_root_len, have_dirlisting, log_requests, def)) == NULL) { return false; } if (log_requests) { if (!vhost->log->create(dir, filename, log_format, bufsize * 1024, access_log_max_file_size * 1024L)) { logger::instance().log(logger::LOG_ERROR, "Couldn't create access log for host %s.", host); return false; } } if (have_dirlisting) { if (conf.get_value(value, len, "config", "hosts", host, "directory_listing_footer", NULL)) { if (!vhost->dir_listing->load_footer(value)) { logger::instance().log(logger::LOG_ERROR, "Couldn't load footer file %s for host %s.", value, host); return false; } } else if (general_conf.footer_file) { if (!vhost->dir_listing->load_footer(general_conf.footer_file)) { logger::instance().log(logger::LOG_ERROR, "Couldn't load footer file %s for host %s.", general_conf.footer_file, host); return false; } } } for (unsigned j = 0; conf.get_child(j, value, len, "config", "hosts", host, "aliases", NULL); j++) { if (!_M_vhosts.add_alias(vhost, value, len)) { return false; } } if (!load_rules(conf, general_conf, host, vhost->rules)) { return false; } } return (_M_vhosts.count() > 0); }
static STANDARDIZER * CreateStd(char *lextab, char *gaztab, char *rultab) { STANDARDIZER *std; LEXICON *lex; LEXICON *gaz; RULES *rules; int err; int SPIcode; DBG("Enter: CreateStd"); SPIcode = SPI_connect(); if (SPIcode != SPI_OK_CONNECT) { elog(ERROR, "CreateStd: couldn't open a connection to SPI"); } std = std_init(); if (!std) elog(ERROR, "CreateStd: could not allocate memory (std)"); lex = lex_init(std->err_p); if (!lex) { std_free(std); SPI_finish(); elog(ERROR, "CreateStd: could not allocate memory (lex)"); } err = load_lex(lex, lextab); if (err == -1) { lex_free(lex); std_free(std); SPI_finish(); elog(ERROR, "CreateStd: failed to load '%s' for lexicon", lextab); } gaz = lex_init(std->err_p); if (!gaz) { lex_free(lex); std_free(std); SPI_finish(); elog(ERROR, "CreateStd: could not allocate memory (gaz)"); } err = load_lex(gaz, gaztab); if (err == -1) { lex_free(gaz); lex_free(lex); std_free(std); SPI_finish(); elog(ERROR, "CreateStd: failed to load '%s' for gazeteer", gaztab); } rules = rules_init(std->err_p); if (!rules) { lex_free(gaz); lex_free(lex); std_free(std); SPI_finish(); elog(ERROR, "CreateStd: could not allocate memory (rules)"); } err = load_rules(rules, rultab); if (err == -1) { rules_free(rules); lex_free(gaz); lex_free(lex); std_free(std); SPI_finish(); elog(ERROR, "CreateStd: failed to load '%s' for rules", rultab); } std_use_lex(std, lex); std_use_gaz(std, gaz); std_use_rules(std, rules); std_ready_standardizer(std); SPI_finish(); return std; }
void load_config( _SaganDebug *debug, _SaganConfig *config ) { FILE *sagancfg; char normfile[MAXPATH]; char *filename; char ruleset[MAXPATH]; char tmpbuf[CONFBUF]; char tmpstring[CONFBUF]; char *sagan_option=NULL; char *sagan_var=NULL; char *ptmp=NULL; char *tok=NULL; int i,check; /* Set some system defaults */ snprintf(config->sagan_alert_filepath, sizeof(config->sagan_alert_filepath), "%s", ALERTLOG); snprintf(config->sagan_lockfile, sizeof(config->sagan_lockfile), "%s", LOCKFILE); snprintf(config->sagan_log_path, sizeof(config->sagan_log_path), "%s", SAGANLOGPATH); config->sagan_proto = 17; /* Default to UDP */ config->max_output_threads = MAX_OUTPUT_THREADS; config->max_processor_threads = MAX_PROCESSOR_THREADS; /* Start loading configuration */ rulestruct = (_Rule_Struct *) realloc(rulestruct, (counters->rulecount+1) * sizeof(_Rule_Struct)); /* Gather information for the master configuration file */ if ((sagancfg = fopen(config->sagan_config, "r")) == NULL) { fprintf(stderr, "[%s, line %d] Cannot open configuration file (%s)\n", __FILE__, __LINE__, config->sagan_config); exit(1); } while(fgets(tmpbuf, sizeof(tmpbuf), sagancfg) != NULL) { if (tmpbuf[0] == '#') continue; if (tmpbuf[0] == ';') continue; if (tmpbuf[0] == 10 ) continue; if (tmpbuf[0] == 32 ) continue; sagan_option = strtok_r(tmpbuf, " ", &tok); if (!strcmp(remrt(sagan_option), "max_output_threads")) { sagan_var = strtok_r(NULL, " ", &tok); config->max_output_threads = atol(sagan_var); } if (!strcmp(remrt(sagan_option), "max_processor_threads")) { sagan_var = strtok_r(NULL, " ", &tok); config->max_processor_threads = atol(sagan_var); } if (!strcmp(remrt(sagan_option), "disable_dns_warnings")) { sagan_log(config, 0, "Supressing DNS warnings"); config->disable_dns_warnings = 1; } if (!strcmp(remrt(sagan_option), "syslog_src_lookup")) { sagan_log(config, 0, "DNS lookup of source address supplied by syslog daemon"); config->syslog_src_lookup = 1; } if (!strcmp(sagan_option, "sagan_host")) { snprintf(config->sagan_host, sizeof(config->sagan_host)-1, "%s", strtok_r(NULL, " " , &tok)); config->sagan_host[strlen(config->sagan_host)-1] = '\0'; } if (!strcmp(sagan_option, "sagan_port")) { sagan_var = strtok_r(NULL, " ", &tok); config->sagan_port = atoi(sagan_var); } #ifndef HAVE_LIBESMTP if (!strcmp(sagan_option, "send-to") || !strcmp(sagan_option, "min_email_priority")) sagan_log(config,1, "\"libesmtp\" support not found. Re-compile with ESMTP support or disable in the sagan.conf."); #endif #ifdef HAVE_LIBESMTP if (!strcmp(sagan_option, "send-to")) { sagan_var = strtok_r(NULL, " ", &tok); snprintf(config->sagan_esmtp_to, sizeof(config->sagan_esmtp_to), "%s", sagan_var); remrt(config->sagan_esmtp_to); config->sagan_esmtp_flag=1; config->sagan_sendto_flag=1; } if (!strcmp(sagan_option, "min_email_priority")) { sagan_var = strtok_r(NULL, " ", &tok); config->min_email_priority = atoi(sagan_var); } #endif #ifndef HAVE_LIBPCAP if (!strcmp(sagan_option, "plog_interface") || !strcmp(sagan_option, "plog_logdev") || !strcmp(sagan_option, "plog_port")) sagan_log(config,1, "\"libpcap\" support not found. Re-compile with PCAP support or disable in the sagan.conf."); #endif #ifdef HAVE_LIBPCAP if (!strcmp(sagan_option, "plog_interface")) { snprintf(config->plog_interface, sizeof(config->plog_interface)-1, "%s", strtok_r(NULL, " ", &tok)); config->plog_interface[strlen(config->plog_interface)-1] = '\0'; config->plog_flag=1; } if (!strcmp(sagan_option, "plog_logdev")) { snprintf(config->plog_logdev, sizeof(config->plog_logdev)-1, "%s", strtok_r(NULL, " ", &tok)); config->plog_logdev[strlen(config->plog_logdev)-1] = '\0'; config->plog_flag=1; } if (!strcmp(sagan_option, "plog_port")) { sagan_var = strtok_r(NULL, " ", &tok); config->plog_port = atoi(sagan_var); config->plog_flag = 1; } #endif #if defined(HAVE_LIBMYSQLCLIENT_R) || defined(HAVE_LIBPQ) if (!strcmp(sagan_option, "sagan_proto")) { sagan_var = strtok_r(NULL, " ", &tok); config->sagan_proto = atoi(sagan_var); } if (!strcmp(sagan_option, "sagan_hostname")) { snprintf(config->sagan_hostname, sizeof(config->sagan_hostname)-1, "%s", strtok_r(NULL, " ", &tok)); config->sagan_hostname[strlen(config->sagan_hostname)-1] = '\0'; } if (!strcmp(sagan_option, "sagan_interface")) { snprintf(config->sagan_interface, sizeof(config->sagan_interface)-1, "%s", strtok_r(NULL, " ", &tok)); config->sagan_interface[strlen(config->sagan_interface)-1] = '\0'; } if (!strcmp(sagan_option, "sagan_filter")) { snprintf(config->sagan_filter, sizeof(config->sagan_filter)-1, "%s", strtok_r(NULL, " ", &tok)); config->sagan_filter[strlen(config->sagan_filter)-1] = '\0'; } if (!strcmp(sagan_option, "sagan_detail")) { sagan_var = strtok_r(NULL, " ", &tok); config->sagan_detail = atoi(sagan_var); } #endif #ifndef HAVE_LIBLOGNORM if (!strcmp(sagan_option, "normalize:")) { sagan_log(config, 0, "WARNING: Sagan was not compiled with \"liblognorm\" support!"); sagan_log(config, 0, "WARNING: Sagan will continue, but _without_ liblognorm!"); } #endif #ifdef HAVE_LIBLOGNORM /* We load the location for liblognorm's 'rule base/samples'. We don't want to load them quiet yet. We only want to load samples we need, so we do the actual ln_loadSamples() after the configuration file and all rules have been analyzed */ if (!strcmp(sagan_option, "normalize:")) { liblognormstruct = (liblognorm_struct *) realloc(liblognormstruct, (liblognorm_count+1) * sizeof(liblognorm_struct)); sagan_var = strtok_r(NULL, ",", &tok); remspaces(sagan_var); snprintf(liblognormstruct[liblognorm_count].type, sizeof(liblognormstruct[liblognorm_count].type), "%s", sagan_var); snprintf(tmpstring, sizeof(tmpstring), "%s", strtok_r(NULL, ",", &tok)); remspaces(tmpstring); tmpstring[strlen(tmpstring)-1] = '\0'; strlcpy(normfile, sagan_replace_str(tmpstring, "$RULE_PATH", config->sagan_rule_path), sizeof(normfile)); snprintf(liblognormstruct[liblognorm_count].filepath, sizeof(liblognormstruct[liblognorm_count].filepath), "%s", normfile); liblognorm_count++; } #endif if (!strcmp(sagan_option, "output")) { config->output_thread_flag = 1; sagan_var = strtok_r(NULL," ", &tok); if (!strcmp(sagan_var, "external:")) { config->sagan_ext_flag=1; snprintf(config->sagan_extern, sizeof(config->sagan_extern), "%s", strtok_r(NULL, " ", &tok)); if (strstr(strtok_r(NULL, " ", &tok), "parsable")) config->sagan_exttype=1; } #ifdef WITH_SNORTSAM if (!strcmp(sagan_var, "alert_fwsam:")) { snprintf(config->sagan_fwsam_info, sizeof(config->sagan_fwsam_info), "%s", remrt(strtok_r(NULL, " ", &tok))); config->sagan_fwsam_flag=1; } #endif #ifndef HAVE_LIBDNET if (!strcmp(sagan_var, "unified2:")) { sagan_log(config, 0,"\"libdnet\" support not found. This is needed for unified2."); sagan_log(config, 1, "Re-compile with libdnet support or disable in the sagan.conf."); } #endif #ifdef HAVE_LIBDNET if (!strcmp(sagan_var, "unified2:")) { config->sagan_unified2_flag = 1; ptmp = sagan_var; remrt(ptmp); while (ptmp != NULL ) { if (!strcmp(ptmp, "filename")) { ptmp = strtok_r(NULL, ",", &tok); snprintf(config->unified2_filepath, sizeof(config->unified2_filepath), "%s/%s", config->sagan_log_path, ptmp); } if (!strcmp(ptmp, "limit")) { ptmp = strtok_r(NULL, " ", &tok); config->unified2_limit = atoi(ptmp) * 1024 * 1024; } if (!strcmp(ptmp, "nostamp")) config->unified2_nostamp = 1; ptmp = strtok_r(NULL, " ", &tok); } } #endif #ifndef HAVE_LIBPRELUDE if (!strcmp(sagan_var, "prelude:")) sagan_log(config,1, " libprelude support not found. Re-compile with Prelude support or disable in the sagan.conf."); #endif #ifdef HAVE_LIBPRELUDE if (!strcmp(sagan_var, "prelude:")) { ptmp = sagan_var; while (ptmp != NULL ) { if (!strcmp(ptmp, "profile")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->sagan_prelude_profile, sizeof(config->sagan_prelude_profile), "%s", ptmp); remrt(config->sagan_prelude_profile); config->sagan_prelude_flag=1; } ptmp = strtok_r(NULL, "=", &tok); } } #endif #ifdef HAVE_LIBESMTP if (!strcmp(sagan_var, "email:")) { ptmp = sagan_var; while (ptmp != NULL ) { if (!strcmp(ptmp, "from")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->sagan_esmtp_from, sizeof(config->sagan_esmtp_from), "%s", ptmp); remrt(config->sagan_esmtp_from); } if (!strcmp(ptmp, "smtpserver")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->sagan_esmtp_server, sizeof(config->sagan_esmtp_server), "%s", ptmp); remrt(config->sagan_esmtp_server); } ptmp = strtok_r(NULL, "=", &tok); } } #endif #if defined(HAVE_LIBMYSQLCLIENT_R) || defined(HAVE_LIBPQ) /* output type (database, etc) */ if (!strcmp(sagan_var, "database:")) { sagan_var = strtok_r(NULL, ",", &tok); /* Type (only "log" is used right now */ if (!strcmp(sagan_var, "log")) { sagan_var = strtok_r(NULL, ",", &tok); } /* MySQL/PostgreSQL/Oracle/etc */ remspaces(sagan_var); if (!strcmp(sagan_var, "mysql" )) { #ifndef HAVE_LIBMYSQLCLIENT_R sagan_log(config, 1,"MySQL support not found. Re-compile with MySQL support or disable in the sagan.conf."); #endif config->dbtype=1; } if (!strcmp(sagan_var, "postgresql" )) { #ifndef HAVE_LIBPQ sagan_log(config, 1,"PostgreSQL support not found. Re-compile with PostgreSQL support or disable in the sagan.conf."); #endif config->dbtype=2; } sagan_var = strtok_r(NULL, ",", &tok); remrt(sagan_var); /* rm NL */ strlcpy(tmpbuf, sagan_var, sizeof(tmpbuf)); ptmp = strtok_r(tmpbuf, "=", &tok); while (ptmp != NULL) { remspaces(ptmp); if (!strcmp(ptmp, "user")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->dbuser, sizeof(config->dbuser), "%s", ptmp); } if (!strcmp(ptmp , "password")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->dbpassword, sizeof(config->dbpassword), "%s", ptmp); } if (!strcmp(ptmp, "dbname")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->dbname, sizeof(config->dbname), "%s", ptmp); } if (!strcmp(ptmp, "host")) { ptmp = strtok_r(NULL, " ", &tok); snprintf(config->dbhost, sizeof(config->dbhost), "%s", ptmp); } if (!strcmp(ptmp, "port")) { config->dbport = atoi(ptmp); } ptmp = strtok_r(NULL, "=", &tok); } } #endif } /* "var" */ if (!strcmp(sagan_option, "var")) { sagan_var = strtok_r(NULL, " ", &tok); if (config->sagan_fifo_flag == 0 ) { /* File overides FIFO settings */ if (!strcmp(sagan_var, "FIFO" )) { snprintf(config->sagan_fifo, sizeof(config->sagan_fifo), "%s", strtok_r(NULL, " ", &tok)); config->sagan_fifo[strlen(config->sagan_fifo)-1] = '\0'; } } if (!strcmp(sagan_var, "RULE_PATH" )) { snprintf(config->sagan_rule_path, sizeof(config->sagan_rule_path), "%s", strtok_r(NULL, " ", &tok)); config->sagan_rule_path[strlen(config->sagan_rule_path)-1] = '\0'; } if (!strcmp(sagan_var, "LOCKFILE" )) { snprintf(config->sagan_lockfile, sizeof(config->sagan_lockfile), "%s", strtok_r(NULL, " ", &tok)); config->sagan_lockfile[strlen(config->sagan_lockfile)-1] = '\0'; } if (!strcmp(sagan_var, "ALERTLOG" )) { snprintf(config->sagan_alert_filepath, sizeof(config->sagan_alert_filepath), "%s", strtok_r(NULL, " ", &tok)); config->sagan_alert_filepath[strlen(config->sagan_alert_filepath)-1] = '\0'; } if (!strcmp(sagan_var, "SAGANLOGPATH" )) { snprintf(config->sagan_log_path, sizeof(config->sagan_log_path), "%s", strtok_r(NULL, " ", &tok)); config->sagan_log_path[strlen(config->sagan_log_path)-1] = '\0'; } } /* "include */ if (!strcmp(sagan_option, "include" )) { snprintf(tmpstring, sizeof(tmpstring), "%s", strtok_r(NULL, " ", &tok)); tmpstring[strlen(tmpstring)-1] = '\0'; strlcpy(ruleset, sagan_replace_str(tmpstring, "$RULE_PATH", config->sagan_rule_path), sizeof(ruleset)); filename=sagan_getfilename(ruleset); /* Get the file name to figure out "what" we're loading */ if (!strcmp(filename, "classification.config")) { load_classifications(debug, config, ruleset); } if (!strcmp(filename, "reference.config")) { load_reference(debug, config, ruleset); } /* It's not a classifcations file or reference, so it must be a ruleset */ if (strcmp(filename, "reference.config") && strcmp(filename, "classification.config")) { load_rules(debug, config, ruleset); } } } fclose(sagancfg); /* Check rules for duplicate sid. We can't have that! */ for (i = 0; i < counters->rulecount; i++) { for ( check = i+1; check < counters->rulecount; check ++) { if (!strcmp (rulestruct[check].s_sid, rulestruct[i].s_sid )) sagan_log(config, 1, "[%s, line %d] Detected duplicate signature id [sid] number %s. Please correct this.", __FILE__, __LINE__, rulestruct[check].s_sid, rulestruct[i].s_sid); } } /* If we have the "send-to" option, verify the configuration has the proper smtpserver, etc. */ #ifdef HAVE_LIBESMTP if (config->sagan_esmtp_flag && !strcmp(config->sagan_esmtp_server, "")) sagan_log(config, 1, "[%s, line %d] Configuration SMTP 'smtpserver' field is missing! |%s|", __FILE__, __LINE__, config->sagan_esmtp_server); if (config->sagan_esmtp_flag && !strcmp(config->sagan_esmtp_from, "" )) sagan_log(config, 1, "[%s, line %d] Configuration SMTP 'from' field is missing!", __FILE__, __LINE__); #endif if (!strcmp(config->sagan_fifo, "")) sagan_log(config, 1, "No FIFO option found which is required! Aborting!"); if (!strcmp(config->sagan_host, "" )) sagan_log(config, 1, "The 'sagan_host' option was not found and is required."); if ( config->sagan_port == 0 ) sagan_log(config, 1, "The 'sagan_port' option was not set and is required."); }