--- /dev/null
+75
+-- added back InspectApi.pinit() and InspectApi.pterm()
+-- eliminated InspectApi.stop()
+-- changed signature to Inspector::configure()
+-- Inspector::init() and term() are now pinit() and pterm()! beware!
+ (for consistency with naming scheme)
+-- other changes to InspectApi / Inspector per comments in header
+
+74
+-- started this ChangeLog for internal use only
+-- fixed -A none and -K none
+-- more refactoring of ftp/telnet and modularization
+-- changed lua/*.lua to EXTRA_DIST to avoid installation overwrites
+-- updated snort.lua wrt the legacy include - read comments therein
+
PacketManager::set_grinder();
- // perfmon, for one, opens a log file for writing here
- InspectorManager::post_config(snort_conf);
-
FileAPIPostInit();
Encode_Init();
int Flow::set_application_data(FlowData* fd)
{
FlowData *appData = get_application_data(fd->get_id());
+ assert(appData != fd);
if (appData)
free_application_data(appData);
class Inspector
{
public:
+ // main thread functions
virtual ~Inspector();
- virtual void configure(SnortConfig*) { };
- virtual int verify(SnortConfig*) { return 0; };
-
- virtual void setup(SnortConfig*) { }; // unprivileged init, stream_api etc.
+ // access external dependencies here
+ // return verification status
+ virtual bool configure(SnortConfig*) { return true; };
virtual void show(SnortConfig*) { };
+ // packet thread functions
+ virtual void pinit() { };
+ virtual void pterm() { };
+
virtual void eval(Packet*) = 0;
virtual void meta(int, const uint8_t*) { };
- virtual void init() { }; // allocate thread local runtime data based on config
- virtual void term() { }; // release thread local runtime data
- virtual void reset() { }; //
-
+ // framework support
unsigned get_ref(unsigned i) { return ref_count[i]; };
void set_ref(unsigned i, unsigned r) { ref_count[i] = r; };
static THREAD_LOCAL unsigned slot;
protected:
- Inspector();
+ // main thread functions
+ Inspector(); // internal init only at this point
private:
unsigned* ref_count;
PRIORITY_MAX
};
-typedef void (*PreprocFunc)();
-typedef void* (*PreprocInitFunc)(void*);
-
-// FIXIT these should take no arg now
-typedef void (*PreprocClassFunc)(void*);
-
-typedef Inspector* (*PreprocCtorFunc)(Module*);
+typedef Inspector* (*PreprocCtor)(Module*);
typedef void (*PreprocDtorFunc)(Inspector*);
+typedef void (*PreprocFunc)();
-// FIXIT ensure all pp's provide stats
+// FIXIT ensure all provide stats
struct InspectApi
{
BaseApi base;
uint16_t proto_bits;
// main thread funcs - parse time data only
- PreprocFunc init; // allocate process static data
- PreprocFunc term; // release init() data
-
- PreprocCtorFunc ctor;
- PreprocDtorFunc dtor;
+ PreprocFunc init; // allocate process static data
+ PreprocFunc term; // release init() data
+ PreprocCtor ctor; // instantiate inspector from Module data
+ PreprocDtorFunc dtor; // release inspector instance
// packet thread funcs - runtime data only
- PreprocClassFunc stop; // stop packet processing // FIXIT same as purge?
- PreprocClassFunc purge; // purge caches
- PreprocClassFunc sum; // accumulate stats
- PreprocClassFunc stats; // output stats
- PreprocClassFunc reset; // clear stats
+ PreprocFunc pinit; // plugin thread local allocation
+ PreprocFunc pterm; // plugin thread local cleanup
+ PreprocFunc purge; // purge caches
+ PreprocFunc sum; // accumulate stats
+ PreprocFunc stats; // output stats
+ PreprocFunc reset; // clear stats
};
#endif
struct PHClass {
const InspectApi& api;
- void* data;
- PHClass(const InspectApi& p) : api(p)
- {
- // FIXIT this should be Module* and data
- data = nullptr;
- };
- ~PHClass()
- {
- }
+ PHClass(const InspectApi& p) : api(p) { };
+ ~PHClass() { };
+
static bool comp (PHClass* a, PHClass* b)
{ return ( a->api.priority < b->api.priority ); };
};
{
for ( auto* p : sc->framework_config->ph_list )
if ( p->api.stats )
- p->api.stats(p->data);
+ p->api.stats();
}
void InspectorManager::accumulate (SnortConfig* sc)
for ( auto* p : sc->framework_config->ph_list )
if ( p->api.sum )
- p->api.sum(p->data);
+ p->api.sum();
pc_sum();
stats_mutex.unlock();
{
for ( auto* p : sc->framework_config->ph_list )
if ( p->api.reset )
- p->api.reset(p->data);
-}
-
-int InspectorManager::check_config(SnortConfig* sc)
-{
- InspectionPolicy* pi = get_inspection_policy();
-
- for ( auto* p : pi->framework_policy->ph_list )
- {
- if ( int rval = p->handler->verify(sc) )
- return rval;
- }
- return 0;
+ p->api.reset();
}
// this is per thread
-void InspectorManager::post_config(SnortConfig* sc)
-{
- InspectionPolicy* pi = get_inspection_policy();
-
- if ( !pi->framework_policy )
- return;
-
- for ( auto* p : pi->framework_policy->ph_list )
- {
- p->handler->setup(sc);
- }
-}
-
-void InspectorManager::thread_init(SnortConfig*, unsigned slot)
+void InspectorManager::thread_init(SnortConfig* sc, unsigned slot)
{
EventManager::open_outputs();
IpsManager::setup_options();
Inspector::slot = slot;
+
+ for ( auto* p : sc->framework_config->ph_list )
+ if ( p->api.pinit )
+ p->api.pinit();
+
InspectionPolicy* pi = get_inspection_policy();
if ( !pi->framework_policy )
return;
for ( auto* p : pi->framework_policy->ph_list )
- p->handler->init();
+ p->handler->pinit();
}
void InspectorManager::thread_term(SnortConfig* sc)
{
- shutdown(sc);
-
InspectionPolicy* pi = get_inspection_policy();
if ( !pi || !pi->framework_policy )
return;
for ( auto* p : pi->framework_policy->ph_list )
- p->handler->term();
+ p->handler->pterm();
+
+ for ( auto* p : sc->framework_config->ph_list )
+ if ( p->api.pterm )
+ p->api.pterm();
accumulate(sc);
IpsManager::clear_options();
EventManager::close_outputs();
}
-// FIXIT this does 2 things due to the convolution of class and global data
-// first it purges all preprocs - this operates on global data like session caches
-// then it resets all instances
+// purges all inspector plugins - eg global session caches
void InspectorManager::reset (SnortConfig* sc)
{
for ( auto* p : sc->framework_config->ph_list )
{
if ( p->api.purge )
- p->api.purge(p->data);
- }
- InspectionPolicy* pi = get_inspection_policy();
-
- if ( !pi->framework_policy )
- return;
-
- for ( auto* p : pi->framework_policy->ph_list )
- p->handler->reset();
-}
-
-// this is the last chance to process data - interact with other modules
-// after this preprocs are being freed and can't be used to process data
-void InspectorManager::shutdown (SnortConfig* sc)
-{
- Active_Suspend();
-
- for ( auto* p : sc->framework_config->ph_list )
- {
- if ( p->api.stop )
- p->api.stop(p->data);
+ p->api.purge();
}
}
}
}
-void InspectorManager::configure(SnortConfig *sc)
+bool InspectorManager::configure(SnortConfig *sc)
{
Inspector::max_slots = sc->max_threads;
s_handlers.sort(PHGlobal::comp);
// FIXIT use FrameworkConfig or FrameworkPolicy ?
//FrameworkConfig* fc = sc->framework_config;
FrameworkPolicy* fp = sc->policy_map->inspection_policy[0]->framework_policy;
+ bool ok = true;
for ( auto* p : fp->ph_list )
- p->handler->configure(sc);
+ ok = p->handler->configure(sc) && ok;
fp->ph_list.sort(PHInstance::comp);
fp->Vectorize();
+
+ return ok;
}
void InspectorManager::print_config(SnortConfig *sc)
static void accumulate(SnortConfig*);
static void reset_stats(SnortConfig*);
static void reset(SnortConfig*);
- static void shutdown(SnortConfig*);
static void instantiate(const InspectApi*, Module*, SnortConfig*);
- static void configure(SnortConfig*);
- static int check_config(SnortConfig*);
+ static bool configure(SnortConfig*);
static void print_config(SnortConfig*);
- static void post_config(SnortConfig*);
static void thread_init(SnortConfig*, unsigned);
static void thread_term(SnortConfig*);
static void as_dtor(Inspector* p)
{ delete p; }
-static void as_sum(void*)
+static void as_sum()
{ sum_stats(&gasstats, &asstats); }
-static void as_stats(void*)
+static void as_stats()
{ show_stats(&gasstats, MOD_NAME); }
-static void as_reset(void*)
+static void as_reset()
{ memset(&gasstats, 0, sizeof(gasstats)); }
static const InspectApi as_api =
nullptr, // term
as_ctor,
as_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
as_sum,
as_stats,
Defrag(DefragEngineModule*);
~Defrag();
- void configure(SnortConfig*);
- int verify(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
- void init();
- void term();
+ void pinit();
+ void pterm();
private:
int insert(Packet*, FragTracker*, FRAGKEY*, FragEngine*);
Share::release(global);
}
-void Defrag::configure(SnortConfig*)
+bool Defrag::configure(SnortConfig*)
{
global = (FragData*)Share::acquire(GLOBAL_KEYWORD);
config.common = global->data;
+ SFAT_SetPolicyIds(FragPolicyIdFromHostAttributeEntry);
+ return true;
}
-void Defrag::init()
+void Defrag::pinit()
{
FragInitCache(&config);
pkt_snaplen = DAQ_GetSnapLen();
}
-void Defrag::term()
+void Defrag::pterm()
{
sfxhash_delete(f_cache);
f_cache = NULL;
encap_defrag_pkt = NULL;
}
-int Defrag::verify(SnortConfig*)
-{
- SFAT_SetPolicyIds(FragPolicyIdFromHostAttributeEntry);
- return 0;
-}
-
void Defrag::show(SnortConfig*)
{
FragPrintGlobalConfig(&config); // FIXIT only show once; need separate inspector method?
#endif
}
-static void de_sum(void*)
+static void de_sum()
{
sum_stats((PegCount*)&g_stats, (PegCount*)&t_stats, array_size(peg_names));
}
-static void de_stats(void*)
+static void de_stats()
{
show_stats((PegCount*)&g_stats, peg_names, array_size(peg_names), ENGINE_KEYWORD);
}
-static void de_reset(void*)
+static void de_reset()
{
if (f_cache != NULL)
sfxhash_make_empty(f_cache);
nullptr, // term
de_ctor,
de_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
de_sum,
de_stats,
public:
Normalizer(NormalizeModule*);
- void configure(SnortConfig*);
- void setup(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
- bool enabled();
private:
NormalizerConfig config;
disabled = false;
}
-bool Normalizer::enabled ()
-{
- return !disabled;
-}
-
-void Normalizer::configure(SnortConfig*)
+bool Normalizer::configure(SnortConfig*)
{
// FIXIT detection policy can't be used by normalizer
// (not set until after normalizer runs)
{
LogMessage("WARNING: normalizations disabled because not inline.\n");
disabled = true;
- return;
+ return true;
}
- InspectionPolicy* policy = get_inspection_policy();
- policy->normal_mask = config.normalizer_flags;
-}
+ InspectionPolicy* ips = get_inspection_policy();
+ ips->normal_mask = config.normalizer_flags;
-void Normalizer::setup(SnortConfig*)
-{
- NetworkPolicy* policy = get_network_policy();
+ NetworkPolicy* nap = get_network_policy();
- if ( policy->new_ttl && policy->new_ttl < policy->min_ttl )
+ if ( nap->new_ttl && nap->new_ttl < nap->min_ttl )
{
- policy->new_ttl = policy->min_ttl;
+ nap->new_ttl = nap->min_ttl;
}
Norm_SetConfig(&config);
+ return true;
}
void Normalizer::show(SnortConfig* sc)
#endif
}
-static void no_sum(void*)
+static void no_sum()
{
Norm_SumStats();
Stream_SumNormalizationStats();
}
-static void no_stats(void*)
+static void no_stats()
{
Norm_PrintStats(name);
Stream_PrintNormalizationStats();
}
-static void no_reset(void*)
+static void no_reset()
{
Norm_ResetStats();
Stream_ResetNormalizationStats();
nullptr, // term
no_ctor,
no_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
no_sum,
no_stats,
PerfMonitor(PerfMonModule*);
~PerfMonitor();
- void setup(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
- void init();
- void term();
+ void pinit();
+ void pterm();
void reset();
private:
// FIXIT perfmonitor should be logging to one file and writing record type and
// version fields immediately after timestamp like
// seconds, usec, type, version#, data1, data2, ...
-void PerfMonitor::setup(SnortConfig*)
+bool PerfMonitor::configure(SnortConfig*)
{
PerfMonitorChangeLogFilesPermission();
std::string name;
if ( (config.flowip_fh = sfOpenFlowIPStatsFile(file)) == NULL )
ParseError("Perfmonitor: Cannot open flow-ip stats file '%s'.", file);
}
+ return true;
}
-void PerfMonitor::init()
+void PerfMonitor::pinit()
{
InitPerfStats(&config);
}
PREPROC_PROFILE_END(perfmonStats);
}
-void PerfMonitor::term()
+void PerfMonitor::pterm()
{
if ( config.perf_flags & SFPERF_SUMMARY )
sfPerfStatsSummary(&config);
return new PerfMonitor((PerfMonModule*)m);
}
-static void pm_sum(void*)
+static void pm_sum()
{
sum_stats(&gpmstats, &pmstats);
}
-static void pm_stats(void*)
+static void pm_stats()
{
show_stats(&gpmstats, mod_name);
}
-static void pm_reset(void*)
+static void pm_reset()
{
memset(&gpmstats, 0, sizeof(gpmstats));
}
nullptr, // term
pm_ctor,
pm_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
pm_sum,
pm_stats,
Share::release(global);
}
-void PortScan::configure(SnortConfig* sc)
+bool PortScan::configure(SnortConfig* sc)
{
// FIXIT use fixed base file name
config->logfile = SnortStrdup("portscan.log");
config->common = global->data;
ScSetScannedProtocols(sc, config->detect_scans);
+ return true;
}
-// FIXIT why setup() vs init()?
-void PortScan::setup(SnortConfig*)
+void PortScan::pinit()
{
- if ( !config->logfile )
- return;
+ g_tmp_pkt = Encode_New();
std::string name;
get_instance_file(name, config->logfile);
-
g_logfile = fopen(name.c_str(), "a+");
if (g_logfile == NULL)
FatalError("Portscan log file '%s' could not be opened: %s.\n",
config->logfile, get_error(errno));
}
-}
-
-void PortScan::init()
-{
- g_tmp_pkt = Encode_New();
-
ps_init_hash(config->common->memcap);
}
-void PortScan::term()
+void PortScan::pterm()
{
fclose(g_logfile);
ps_cleanup();
delete p;
}
-static void sp_sum(void*)
+static void sp_sum()
{
sum_stats(&gspstats, &spstats);
}
-static void sp_stats(void*)
+static void sp_stats()
{
show_stats(&gspstats, PS_MODULE);
}
-static void sp_reset(void*)
+static void sp_reset()
{
ps_reset();
memset(&gspstats, 0, sizeof(gspstats));
nullptr, // term
sp_ctor,
sp_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
sp_sum,
sp_stats,
PortScan(class PortScanModule*);
~PortScan();
- void configure(SnortConfig*);
- void setup(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
+
void eval(Packet*);
- void init();
- void term();
+
+ void pinit();
+ void pterm();
private:
void ps_parse(SnortConfig*, char *);
Stream5(Stream5GlobalConfig*);
~Stream5();
- void configure(SnortConfig*);
+ bool configure(SnortConfig*);
int verify_config(SnortConfig*);
- int verify(SnortConfig*);
- void setup(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
- void init();
- void term();
- void reset();
+ void pinit();
+ void pterm();
+ void reset(); // FIXIT delete if not used
private:
Stream5Config config;
Share::release(ip_data);
}
-void Stream5::configure(SnortConfig*)
+bool Stream5::configure(SnortConfig* sc)
{
if ( config.global_config->max_tcp_sessions )
{
ip_data = (StreamIpData*)Share::acquire("stream_ip");
config.ip_config = ip_data->data;
}
+
+#ifdef ENABLE_HA
+ if ( config.ha_config )
+ ha_setup(config.ha_config);
+#endif
+
+ return !verify_config(sc);
}
int Stream5::verify_config(SnortConfig* sc)
return status;
}
-int Stream5::verify(SnortConfig* sc)
-{
- int rval;
-
- if ( (rval = verify_config(sc)) )
- return rval;
-
-#if 0
- // FIXIT no longer valid with thread local flow_con instantiated later
- // also, how is this possible?
- // if just due to failed alloc, then delete
- uint32_t max_tcp = flow_con->max_flows(IPPROTO_TCP);
- uint32_t max_udp = flow_con->max_flows(IPPROTO_UDP);
- uint32_t max_icmp = flow_con->max_flows(IPPROTO_ICMP);
- uint32_t max_ip = flow_con->max_flows(IPPROTO_IP);
-
- uint32_t total_sessions = max_tcp + max_udp + max_icmp + max_ip;
-
- if ( !total_sessions )
- return 0;
-
- if ( (config.global_config->max_tcp_sessions > 0)
- && (max_tcp == 0) )
- {
- LogMessage("TCP tracking disabled, no TCP sessions allocated\n");
- }
-
- if ( (config.global_config->max_udp_sessions > 0)
- && (max_udp == 0) )
- {
- LogMessage("UDP tracking disabled, no UDP sessions allocated\n");
- }
-
- if ( (config.global_config->max_icmp_sessions > 0)
- && (max_icmp == 0) )
- {
- LogMessage("ICMP tracking disabled, no ICMP sessions allocated\n");
- }
-
- if ( (config.global_config->max_ip_sessions > 0)
- && (max_ip == 0) )
- {
- LogMessage("IP tracking disabled, no IP sessions allocated\n");
- }
-
- // FIXIT need to get max or set it here for use by init_exp
- //LogMessage(" Max Expected Streams: %u\n", max);
-#endif
- return 0;
-}
-
-void Stream5::init()
+void Stream5::pinit()
{
assert(!flow_con);
flow_con = new FlowControl(&config);
tcp_sinit(&config);
}
-void Stream5::term()
+void Stream5::pterm()
{
#ifdef ENABLE_HA
Stream5CleanHA();
tcp_sterm();
}
-void Stream5::setup(SnortConfig*)
-{
-#ifdef ENABLE_HA
- if ( config.ha_config )
- ha_setup(config.ha_config);
-#endif
-}
-
void Stream5::show(SnortConfig*)
{
Stream5PrintGlobalConfig(&config);
}
#endif
-static void s5_purge(void*)
+static void s5_purge()
{
flow_con->purge_flows(IPPROTO_TCP);
flow_con->purge_flows(IPPROTO_UDP);
flow_con->purge_flows(IPPROTO_IP);
}
-static void s5_stop(void* pv)
-{
- s5_purge(pv);
-}
-
-static void s5_sum(void*)
+static void s5_sum()
{
sum_stats((PegCount*)&gs5stats.tcp_port_filter,
(PegCount*)&s5stats.tcp_port_filter, array_size(filter_pegs));
ip_sum();
}
-static void s5_stats(void*)
+static void s5_stats()
{
tcp_stats();
#endif
}
-static void s5_reset(void*)
+static void s5_reset()
{
tcp_reset_stats();
udp_reset_stats();
nullptr, // term
s5_ctor,
s5_dtor,
- s5_stop,
+ nullptr, // pinit
+ nullptr, // pterm
s5_purge,
s5_sum,
s5_stats,
class BoPH : public Inspector {
public:
- BoPH();
+ BoPH() { };
void show(SnortConfig*);
void eval(Packet*);
};
-BoPH::BoPH()
-{
-}
-
void BoPH::show(SnortConfig*)
{
LogMessage("%s\n", mod_name);
delete p;
}
-static void bo_sum(void*)
+static void bo_sum()
{
sum_stats(&gbostats, &bostats);
}
-static void bo_stats(void*)
+static void bo_stats()
{
show_stats(&gbostats, mod_name);
}
-static void bo_reset(void*)
+static void bo_reset()
{
memset(&gbostats, 0, sizeof(gbostats));
}
nullptr, // term
bo_ctor,
bo_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
bo_sum,
bo_stats,
FtpServer(FTP_SERVER_PROTO_CONF*);
~FtpServer();
- void configure(SnortConfig*);
- int verify(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
void eval_alt(Packet*);
Share::release(ftp_client);
}
-void FtpServer::configure (SnortConfig* sc)
+bool FtpServer::configure (SnortConfig* sc)
{
ftp_client = (ClientData*)Share::acquire(client_key);
bind_server = ftp_server;
bind_client = ftp_client->data;
-}
-int FtpServer::verify(SnortConfig* sc)
-{
- return FTPCheckConfigs(sc, ftp_server);
+ return !FTPCheckConfigs(sc, ftp_server);
}
void FtpServer::show(SnortConfig*)
delete p;
}
-static void fs_sum(void*)
+static void fs_sum()
{
sum_stats(&gftstats, &ftstats);
}
-static void fs_stats(void*)
+static void fs_stats()
{
show_stats(&gftstats, server_key);
}
-static void fs_reset(void*)
+static void fs_reset()
{
memset(&gftstats, 0, sizeof(gftstats));
}
nullptr, // term
fs_ctor,
fs_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
fs_sum,
fs_stats,
Telnet(TELNET_PROTO_CONF*);
~Telnet();
- void configure(SnortConfig*);
- int verify(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
delete config;
}
-void Telnet::configure(SnortConfig* sc)
+bool Telnet::configure(SnortConfig* sc)
{
stream.set_service_filter_status(
sc, telnet_app_id, PORT_MONITOR_SESSION);
-}
-int Telnet::verify(SnortConfig* sc)
-{
- return TelnetCheckConfigs(sc, config);
+ return !TelnetCheckConfigs(sc, config);
}
void Telnet::show(SnortConfig*)
delete p;
}
-static void tn_sum(void*)
+static void tn_sum()
{
sum_stats(>nstats, &tnstats);
}
-static void tn_stats(void*)
+static void tn_stats()
{
show_stats(>nstats, tn_name);
}
-static void tn_reset(void*)
+static void tn_reset()
{
memset(>nstats, 0, sizeof(gtnstats));
}
nullptr, // term
tn_ctor,
tn_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
tn_sum,
tn_stats,
/****************************************************************************
*
-** Copyright (C) 2014 Cisco and/or its affiliates. All rights reserved.
+ * Copyright (C) 2014 Cisco and/or its affiliates. All rights reserved.
* Copyright (C) 2003-2013 Sourcefire, Inc.
*
* This program is free software; you can redistribute it and/or modify
HttpInspect(HTTPINSPECT_CONF*);
~HttpInspect();
- void configure(SnortConfig*);
- int verify(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
+
void eval(Packet*);
- void init();
- void term();
+
+ void pinit();
+ void pterm();
private:
HTTPINSPECT_CONF* config;
Share::release(global);
}
-void HttpInspect::configure (SnortConfig* sc)
+bool HttpInspect::configure (SnortConfig* sc)
{
global = (HttpData*)Share::acquire(GLOBAL_KEYWORD);
config->global = global->data;
// FIXIT must load default unicode map from const char*
CheckGzipConfig(config->global);
CheckMemcap(config->global);
-}
-int HttpInspect::verify(SnortConfig* sc)
-{
- return HttpInspectVerifyPolicy(sc, config);
+ return !HttpInspectVerifyPolicy(sc, config);
}
-void HttpInspect::init()
+void HttpInspect::pinit()
{
memset(&hi_stats, 0, sizeof(HIStats));
}
}
-void HttpInspect::term()
+void HttpInspect::pterm()
{
// FIXIT this is off-balance; not allocated by sinit()
if ( hi_gzip_mempool && !mempool_destroy(hi_gzip_mempool) )
delete p;
}
-static void hs_sum(void*)
+static void hs_sum()
{
sum_stats((PegCount*)&ghi_stats, (PegCount*)&hi_stats, array_size(peg_names));
}
-static void hs_stats(void*)
+static void hs_stats()
{
show_stats((PegCount*)&ghi_stats, peg_names, array_size(peg_names),
SERVER_KEYWORD);
}
-static void hs_reset(void*)
+static void hs_reset()
{
memset(&ghi_stats, 0, sizeof(ghi_stats));
}
hs_term,
hs_ctor,
hs_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
hs_sum,
hs_stats,
public:
RpcDecode(RpcModule*);
- void configure(SnortConfig*);
+ bool configure(SnortConfig*);
void show(SnortConfig*);
void eval(Packet*);
mod->get_ports(config.ports);
}
-void RpcDecode::configure(SnortConfig* sc)
+bool RpcDecode::configure(SnortConfig* sc)
{
_addPortsToStream5Filter(sc, &config);
_addServicesToStream5Filter(sc);
+ return true;
}
void RpcDecode::show(SnortConfig*)
delete p;
}
-static void rd_sum(void*)
+static void rd_sum()
{
sum_stats(&grdstats, &rdstats);
}
-static void rd_stats(void*)
+static void rd_stats()
{
show_stats(&grdstats, mod_name);
}
-static void rd_reset(void*)
+static void rd_reset()
{
memset(&grdstats, 0, sizeof(grdstats));
}
nullptr, // term
rd_ctor,
rd_dtor,
- nullptr, // stop
+ nullptr, // pinit
+ nullptr, // pterm
nullptr, // purge
rd_sum,
rd_stats,
{
OrderRuleLists(snort_conf, "activation dynamic drop sdrop reject alert pass log");
}
- InspectorManager::configure(snort_conf);
+ if ( !InspectorManager::configure(snort_conf) )
+ SnortFatalExit();
+
InspectorManager::print_config(snort_conf); // FIXIT make optional
ParseRules(snort_conf);
*/
SetRuleStates(snort_conf);
- /* Verify the preprocessors are configured properly */
- if (InspectorManager::check_config(snort_conf))
- SnortFatalExit();
-
SetPortFilterLists(snort_conf); // FIXIT need to do these on reload?
InitServiceFilterStatus(snort_conf);
sc->thiszone = gmt2local(0);
#endif
- InspectorManager::configure(sc);
+ if ( !InspectorManager::configure(sc) )
+ {
+ SnortConfFree(sc);
+ return NULL;
+ }
FlowbitResetCounts();
ParseRules(sc);
//PrintRuleOrder(sc->rule_lists);
SetRuleStates(sc);
-
- if (InspectorManager::check_config(sc))
- {
- SnortConfFree(sc);
- return NULL;
- }
-
SetPortFilterLists(sc);
- InspectorManager::post_config(sc);
/* Need to do this after dynamic detection stuff is initialized, too */
IpsManager::verify();
projects / thirdparty / snort3.git / commitdiff
