uint64_t client_bytes;
uint64_t server_bytes;
struct timeval start_time;
+ uint64_t total_flow_latency;
};
struct LwState
return true;
}
+bool LatencyModule::end(const char*, int, SnortConfig* sc)
+{
+ PacketLatencyConfig& config = sc->latency->packet_latency;
+
+ if (config.max_time > CLOCK_ZERO)
+ config.force_enable = true;
+
+ return true;
+}
+
const RuleMap* LatencyModule::get_rules() const
{ return latency_rules; }
LatencyModule();
bool set(const char*, snort::Value&, snort::SnortConfig*) override;
+ bool end(const char*, int, snort::SnortConfig*) override;
const snort::RuleMap* get_rules() const override;
unsigned get_gid() const override;
void PacketLatency::push()
{
- if ( packet_latency::config->enabled() )
+ if ( packet_latency::config->force_enabled())
{
packet_latency::get_impl().push();
++latency_stats.total_packets;
void PacketLatency::pop(const Packet* p)
{
- if ( packet_latency::config->enabled() )
+ if ( packet_latency::config->force_enabled())
{
if ( packet_latency::get_impl().pop(p) )
++latency_stats.packet_timeouts;
if ( elapsed > latency_stats.max_usecs )
latency_stats.max_usecs = elapsed;
+ if ( p->flow )
+ p->flow->flowstats.total_flow_latency += elapsed;
+
latency_stats.total_usecs += elapsed;
}
}
{
hr_duration max_time = CLOCK_ZERO;
bool fastpath = false;
+ bool force_enable = false;
#ifdef REG_TEST
bool test_timeout = false;
#endif
#endif
return max_time > CLOCK_ZERO;
}
+
+ bool force_enabled() const
+ {
+ return force_enable;
+ }
};
#endif
overlay_trace_config = tc;
}
+bool SnortConfig::set_latency_enable()
+{
+ if (latency)
+ {
+ latency->packet_latency.force_enable = true;
+ return true;
+ }
+ return false;
+}
+
void SnortConfig::set_tunnel_verdicts(const char* args)
{
char* tmp, * tok;
void set_umask(uint32_t);
void set_utc(bool);
void set_overlay_trace_config(TraceConfig*);
+ SO_PUBLIC bool set_latency_enable();
//------------------------------------------------------
// accessor methods