uint16_t size = 1;
uint8_t t = 0;
Buffer buf(&t, size);
- Flow *flow = NULL;
+ Flow *flow = nullptr;
CHECK (grecodec.encode(&raw_in,raw_len,enc,buf,flow) == false);
}
static GHash* alloc_srvmap()
{
// nodes are lists,free them in ghash_delete
- return new GHash(1000, 0, 0, (void (*)(void*))sflist_free);
+ return new GHash(1000, 0, false, (void (*)(void*))sflist_free);
}
static void free_srvmap(GHash* table)
static GHash* alloc_spgmm()
{
// 1000 rows, ascii key
- return new GHash(1000, 0, 0, delete_pg);
+ return new GHash(1000, 0, false, delete_pg);
}
static void free_spgmm(GHash* table)
GHash* OtnLookupNew()
{
- return new GHash(10000, sizeof(OtnKey), 0, OtnFree);
+ return new GHash(10000, sizeof(OtnKey), false, OtnFree);
}
void OtnLookupAdd(GHash* otn_map, OptTreeNode* otn)
const snort::Parameter::Type node_type);
private:
- virtual std::string get_name() const override
+ std::string get_name() const override
{ return name; }
- virtual snort::Parameter::Type get_type() const override
+ snort::Parameter::Type get_type() const override
{ return type; }
- virtual BaseConfigNode* get_node(const std::string& name) override;
+ BaseConfigNode* get_node(const std::string& name) override;
private:
std::string name;
const std::string& name = "");
private:
- virtual std::string get_name() const override
+ std::string get_name() const override
{ return !custom_name.empty() ? custom_name : value.get_name(); }
- virtual snort::Parameter::Type get_type() const override
+ snort::Parameter::Type get_type() const override
{ return value.get_param_type(); }
- virtual const snort::Value* get_value() const override
+ const snort::Value* get_value() const override
{ return &value; }
- virtual void set_value(const snort::Value& v) override;
- virtual BaseConfigNode* get_node(const std::string& name) override;
+ void set_value(const snort::Value& v) override;
+ BaseConfigNode* get_node(const std::string& name) override;
private:
snort::Value value;
void FileIdentifier::init_merge_hash()
{
- identifier_merge_hash = new GHash(1000, sizeof(MergeNode), 0, nullptr);
+ identifier_merge_hash = new GHash(1000, sizeof(MergeNode), false, nullptr);
}
FileIdentifier::~FileIdentifier()
protected:
RuleFlowData(unsigned u);
public:
- virtual ~RuleFlowData() { }
+ ~RuleFlowData() override = default;
};
}
{
}
- virtual ~StashGenericObject()
- {
-
- }
+ virtual ~StashGenericObject() = default;
int get_object_type() const
{
return object_type;
THREAD_LOCAL PacketTracer* snort::s_pkt_trace = nullptr;
void Active::drop_packet(snort::Packet const*, bool) { }
-PacketTracer::~PacketTracer() { }
+PacketTracer::~PacketTracer() = default;
void PacketTracer::log(const char*, ...) { }
void PacketTracer::open_file() { }
void PacketTracer::dump_to_daq(Packet*) { }
void PacketTracer::unpause() { }
void Active::set_drop_reason(char const*) { }
Packet::Packet(bool) { }
-Packet::~Packet() { }
+Packet::~Packet() = default;
Flow::Flow() { memset(this, 0, sizeof(*this)); }
-Flow::~Flow() { }
-DetectionEngine::DetectionEngine() { }
-ExpectCache::~ExpectCache() { }
-DetectionEngine::~DetectionEngine() { }
+Flow::~Flow() = default;
+DetectionEngine::DetectionEngine() = default;
+ExpectCache::~ExpectCache() = default;
+DetectionEngine::~DetectionEngine() = default;
void Flow::init(PktType) { }
void Flow::term() { }
void Flow::flush(bool) { }
DetectionEngine::DetectionEngine() = default;
-DetectionEngine::~DetectionEngine() {}
+DetectionEngine::~DetectionEngine() = default;
bool layer::set_outer_ip_api(const Packet* const, ip::IpApi&, int8_t&)
{ return false; }
Flow::Flow() { ha_state = new FlowHAState; key = new FlowKey; }
Flow::~Flow() { delete key; delete ha_state; }
-FlowStash::~FlowStash() { }
+FlowStash::~FlowStash() = default;
void Flow::set_client_initiate(Packet*) { }
void Flow::set_direction(Packet*) { }
class SO_PUBLIC IpsAction : public ActiveAction
{
public:
- virtual void exec(Packet*) override = 0;
+ void exec(Packet*) override = 0;
const char* get_name() const { return name; }
protected:
{ false, valid_select, "blue", "red | green | yellow" },
{ false, valid_select, "green", nullptr },
- { false, nullptr, 0, nullptr }
+ { false, nullptr, nullptr, nullptr }
// __STRDUMP_ENABLE__
};
{ false, valid_bit_list, "1 2 3 4", "3" },
{ false, valid_bit_list, "128", "3" },
- { false, nullptr, 0, nullptr }
+ { false, nullptr, nullptr, nullptr }
// __STRDUMP_ENABLE__
};
// mocks
//--------------------------------------------------------------------------
InspectionPolicy::InspectionPolicy(unsigned int) {}
-InspectionPolicy::~InspectionPolicy() {}
+InspectionPolicy::~InspectionPolicy() = default;
namespace snort
{
SnortConfig::SnortConfig(snort::SnortConfig const*)
// generic hash table - stores and maps key + data pairs
-#include <string.h>
+#include <cstring>
#include "hash_key_operations.h"
#include "main/snort_types.h"
{
public:
HashKeyOperations(int rows);
- virtual ~HashKeyOperations()
- { }
+ virtual ~HashKeyOperations() = default;
virtual unsigned do_hash(const unsigned char* key, int len);
virtual bool key_compare(const void* key1, const void* key2, size_t len);
string dir_str, proto_str, port_str, ip;
line_stream >> dir_str >> proto_str >> port_str >> ip;
- uint16_t port = strtol(port_str.c_str(), NULL, 10);
+ uint16_t port = strtol(port_str.c_str(), nullptr, 10);
if ( port == 0 )
{
WarningMessage("Discovery Filter: Invalid port at line %u from %s;",
static LiteralSearch* instantiate(
Handle*, const uint8_t* pattern, unsigned pattern_len, bool no_case = false, bool hs = false);
- virtual ~LiteralSearch() { }
+ virtual ~LiteralSearch() = default;
virtual int search(Handle*, const uint8_t* buffer, unsigned buffer_len) const = 0;
protected:
- LiteralSearch() { }
+ LiteralSearch() = default;
};
}
public:
HostCacheIp(const size_t initial_size) : HostCacheIpSpec(initial_size) { }
- bool remove(const KeyType& key)
+ bool remove(const KeyType& key) override
{
LruBase::Data data;
return remove(key, data);
}
- bool remove(const KeyType& key, LruBase::Data& data)
+ bool remove(const KeyType& key, LruBase::Data& data) override
{
bool out = LruBase::remove(key, data);
data->remove_flows();
protected:
- HostCacheInterface* lru = 0;
+ HostCacheInterface* lru = nullptr;
};
template <class T>
void show_stats(PegCount*, const PegInfo*, unsigned, const char*) { }
void show_stats(PegCount*, const PegInfo*, const IndexVec&, const char*, FILE*) { }
-OptTreeNode::~OptTreeNode() { }
+OptTreeNode::~OptTreeNode() = default;
//-------------------------------------------------------------------------
// helpers
#include "messages.h"
+#include <syslog.h>
+
#include <cassert>
#include <cstdarg>
-#include <string.h>
-#include <syslog.h>
+#include <cstring>
#include "main/snort_config.h"
#include "parser/parser.h"
Module(name, "trace_test_help"), test_trace_options(trace_options)
{ }
- virtual const TraceOption* get_trace_options() const
+ const TraceOption* get_trace_options() const override
{ return test_trace_options; }
private:
void Profiler::stop(uint64_t) { }
void Profiler::consolidate_stats() { }
void Swapper::apply(Analyzer&) { }
-Swapper::~Swapper() { }
+Swapper::~Swapper() = default;
void OopsHandler::tinit() { }
void OopsHandler::tterm() { }
uint16_t get_run_num() { return 0; }
void set_thread_type(SThreadType) { }
void ContextSwitcher::push(snort::IpsContext*) { }
void ContextSwitcher::stop() { }
-ContextSwitcher::~ContextSwitcher() { }
+ContextSwitcher::~ContextSwitcher() = default;
snort::IpsContext* ContextSwitcher::get_context() const { return nullptr; }
void ContextSwitcher::start() { }
void InitTag() { }
void packet_gettimeofday(struct timeval* tv) { *tv = s_packet_time; }
MemoryContext::MemoryContext(MemoryTracker&) : saved(nullptr) { }
-MemoryContext::~MemoryContext() { }
+MemoryContext::~MemoryContext() = default;
Packet::Packet(bool)
{
memset(this , 0, sizeof(*this));
void DataBus::publish(const char*, Packet*, Flow*) { }
void DataBus::publish(const char*, DataEvent&, Flow*) { }
SFDAQInstance::SFDAQInstance(const char*, unsigned, const SFDAQConfig*) { }
-SFDAQInstance::~SFDAQInstance() { }
+SFDAQInstance::~SFDAQInstance() = default;
void SFDAQInstance::reload() { }
bool SFDAQInstance::start() { return false; }
bool SFDAQInstance::stop() { return false; }
bool SFDAQ::can_inject() { return false; }
bool SFDAQ::can_inject_raw() { return false; }
int SFDAQInstance::set_packet_verdict_reason(DAQ_Msg_h, uint8_t) { return 0; }
-DetectionEngine::DetectionEngine() { }
-DetectionEngine::~DetectionEngine() { }
+DetectionEngine::DetectionEngine() = default;
+DetectionEngine::~DetectionEngine() = default;
void DetectionEngine::onload() { }
void DetectionEngine::thread_init() { }
void DetectionEngine::thread_term() { }
IpsContext::IpsContext(unsigned) { }
NetworkPolicy* get_network_policy() { return nullptr; }
InspectionPolicy* get_inspection_policy() { return nullptr; }
-Flow::Flow() { }
-Flow::~Flow() { }
+Flow::Flow() = default;
+Flow::~Flow() = default;
void ThreadConfig::implement_thread_affinity(SThreadType, unsigned) { }
}
AppIdContext(AppIdConfig& config) : config(config)
{ }
- ~AppIdContext() { }
+ ~AppIdContext() = default;
OdpContext& get_odp_ctxt() const
{
#ifndef APPID_DEBUG_H
#define APPID_DEBUG_H
-#include <string.h>
+#include <cstring>
#include <daq_common.h>
class AppIdDiscovery
{
public:
- AppIdDiscovery() { }
+ AppIdDiscovery() = default;
virtual ~AppIdDiscovery();
AppIdDiscovery(const AppIdDiscovery&) = delete;
host_end = port_str;
if (*(++port_str) != '\0')
{
- char *end = NULL;
+ char *end = nullptr;
long ret = strtol(port_str, &end, 10);
if (end != port_str && *end == '\0' && ret >= 1 && ret <= PORT_MAX)
{
}
chp_candidate = 0;
- chp_hold_flow = 0;
+ chp_hold_flow = false;
asd.scan_flags &= ~SCAN_HTTP_VIA_FLAG;
asd.scan_flags &= ~SCAN_HTTP_USER_AGENT_FLAG;
asd.scan_flags &= ~SCAN_HTTP_HOST_URL_FLAG;
void get_first_stream_app_ids(AppId& service, AppId& client, AppId& payload, AppId& misc) const;
void get_first_stream_app_ids(AppId& service, AppId& client, AppId& payload) const;
- ~AppIdSessionApi()
+ ~AppIdSessionApi() override
{
delete_session_data();
}
{
public:
SipUdpClientDetector(ClientDiscovery*);
- ~SipUdpClientDetector() override { }
+ ~SipUdpClientDetector() override = default;
int validate(AppIdDiscoveryArgs&) override;
};
}
void ApplicationDescriptor::set_id(const Packet&, AppIdSession&, AppidSessionDirection, AppId, AppidChangeBits&) { }
-AppIdDiscovery::~AppIdDiscovery() { }
+AppIdDiscovery::~AppIdDiscovery() = default;
void ClientDiscovery::initialize(AppIdInspector&) { }
void ClientDiscovery::reload() { }
void AppIdDiscovery::register_detector(const string&, AppIdDetector*, IpProtocol) { }
void AppIdDiscovery::register_tcp_pattern(AppIdDetector*, unsigned char const*, unsigned int, int, unsigned int) { }
void AppIdDiscovery::register_udp_pattern(AppIdDetector*, unsigned char const*, unsigned int, int, unsigned int) { }
int AppIdDiscovery::add_service_port(AppIdDetector*, ServiceDetectorPort const&) { return 0; }
-DnsPatternMatchers::~DnsPatternMatchers() { }
-SipPatternMatchers::~SipPatternMatchers() { }
-SslPatternMatchers::~SslPatternMatchers() { }
+DnsPatternMatchers::~DnsPatternMatchers() = default;
+SipPatternMatchers::~SipPatternMatchers() = default;
+SslPatternMatchers::~SslPatternMatchers() = default;
void AppIdModule::reset_stats() {}
TEST_GROUP(http_url_patterns_tests)
LuaServiceObject(AppIdDiscovery* sdm, const std::string& detector_name,
const std::string& log_name, bool is_custom, IpProtocol protocol, lua_State* L,
OdpContext& odp_ctxt);
- ServiceDetector* get_detector()
+ ServiceDetector* get_detector() override
{ return sd; }
};
LuaClientObject(const std::string& detector_name,
const std::string& log_name, bool is_custom, IpProtocol protocol, lua_State* L,
OdpContext& odp_ctxt);
- ClientDetector* get_detector()
+ ClientDetector* get_detector() override
{ return cd; }
};
class ServiceDiscovery : public AppIdDiscovery
{
public:
- ~ServiceDiscovery() override { }
+ ~ServiceDiscovery() override = default;
void initialize(AppIdInspector&) override;
void reload() override;
void finalize_service_patterns();
AppidChangeBits&) { return 0; }
int ServiceDiscovery::add_ftp_service_state(AppIdSession&) { return 0; }
bool ServiceDiscovery::do_service_discovery(AppIdSession&, Packet*, AppidSessionDirection,
- AppidChangeBits&) { return 0; }
+ AppidChangeBits&) { return false; }
int ServiceDiscovery::incompatible_data(AppIdSession&, const Packet*,AppidSessionDirection,
ServiceDetector*) { return 0; }
int ServiceDiscovery::fail_service(AppIdSession&, const Packet*, AppidSessionDirection,
StashGenericObject(STASH_GENERIC_OBJECT_APPID) {}
}
-SslPatternMatchers::~SslPatternMatchers() { }
-SipPatternMatchers::~SipPatternMatchers() { }
-HttpPatternMatchers::~HttpPatternMatchers() { }
-DnsPatternMatchers::~DnsPatternMatchers() { }
+SslPatternMatchers::~SslPatternMatchers() = default;
+SipPatternMatchers::~SipPatternMatchers() = default;
+HttpPatternMatchers::~HttpPatternMatchers() = default;
+DnsPatternMatchers::~DnsPatternMatchers() = default;
void ClientDiscovery::initialize(AppIdInspector&) {}
void ClientDiscovery::reload() {}
FpSMBData* smb_data = nullptr;
}
int dcerpc_validate(const uint8_t*, int){return 0; }
-AppIdDiscovery::~AppIdDiscovery() { }
+AppIdDiscovery::~AppIdDiscovery() = default;
void show_stats(PegCount*, const PegInfo*, unsigned, const char*) { }
void show_stats(PegCount*, const PegInfo*, const IndexVec&, const char*, FILE*) { }
AppIdConfig config;
return ss;
}
- ServiceDiscoveryState* get(const AppIdServiceStateKey& k, bool do_touch = 0)
+ ServiceDiscoveryState* get(const AppIdServiceStateKey& k, bool do_touch = false)
{
Map_t::const_iterator it = m.find(k);
if ( it != m.end() ) {
{ return &dummy_appid_inspector; }
Packet::Packet(bool) { }
-Packet::~Packet() { }
+Packet::~Packet() = default;
Packet* DetectionEngine::get_current_packet()
{
#include "network_inspectors/appid/appid_debug.cc"
-#include <stdio.h>
-#include <string.h>
+#include <cstdio>
+#include <cstring>
#include "flow/flow.h"
#include "network_inspectors/appid/appid_session.h"
AppIdInspector() = default;
};
-AppIdConfig::~AppIdConfig() { }
+AppIdConfig::~AppIdConfig() = default;
OdpContext::OdpContext(const AppIdConfig&, snort::SnortConfig*) { }
AppIdConfig stub_config;
{
// Stubs for packet
Packet::Packet(bool) {}
-Packet::~Packet() {}
+Packet::~Packet() = default;
bool Packet::get_ip_proto_next(unsigned char&, IpProtocol&) const { return true; }
// Stubs for inspector
// Stubs for search_tool
SearchTool::SearchTool(const char*, bool) {}
-SearchTool::~SearchTool() {}
+SearchTool::~SearchTool() = default;
void SearchTool::add(const char*, unsigned, int, bool) {}
void SearchTool::add(const char*, unsigned, void*, bool) {}
void SearchTool::add(const uint8_t*, unsigned, int, bool) {}
// Stubs for matchers
static HttpPatternMatchers* http_matchers;
-DnsPatternMatchers::~DnsPatternMatchers() { }
-HttpPatternMatchers::~HttpPatternMatchers() {}
+DnsPatternMatchers::~DnsPatternMatchers() = default;
+HttpPatternMatchers::~HttpPatternMatchers() = default;
void HttpPatternMatchers::get_http_offsets(Packet*, AppIdHttpSession*) {}
-SipPatternMatchers::~SipPatternMatchers() { }
-SslPatternMatchers::~SslPatternMatchers() { }
+SipPatternMatchers::~SipPatternMatchers() = default;
+SslPatternMatchers::~SslPatternMatchers() = default;
void ApplicationDescriptor::set_id(const Packet&, AppIdSession&, AppidSessionDirection, AppId, AppidChangeBits&) { }
void ApplicationDescriptor::set_id(AppId app_id){my_id = app_id;}
// Stubs for AppIdModule
AppIdModule::AppIdModule(): Module("appid_mock", "appid_mock_help") {}
-AppIdModule::~AppIdModule() {}
+AppIdModule::~AppIdModule() = default;
void AppIdModule::sum_stats(bool) {}
void AppIdModule::show_dynamic_stats() {}
bool AppIdModule::begin(char const*, int, SnortConfig*) { return true; }
void AppIdSession::examine_rtmp_metadata(AppidChangeBits&) {}
void AppIdSession::examine_ssl_metadata(AppidChangeBits&) {}
void AppIdSession::update_encrypted_app_id(AppId) {}
-bool AppIdSession::is_tp_processing_done() const {return 0;}
+bool AppIdSession::is_tp_processing_done() const {return false;}
AppId AppIdSession::pick_ss_payload_app_id(AppId) const { return get_payload_id(); }
AppIdSession* AppIdSession::allocate_session(const Packet*, IpProtocol,
AppidSessionDirection, AppIdInspector&, OdpContext&)
AppidChangeBits&) { return 0; }
int ServiceDiscovery::add_ftp_service_state(AppIdSession&) { return 0; }
bool ServiceDiscovery::do_service_discovery(AppIdSession&, Packet*, AppidSessionDirection,
- AppidChangeBits&) { return 0; }
+ AppidChangeBits&) { return false; }
int ServiceDiscovery::incompatible_data(AppIdSession&, const Packet*,AppidSessionDirection,
ServiceDetector*) { return 0; }
int ServiceDiscovery::fail_service(AppIdSession&, const Packet*, AppidSessionDirection,
{
AppIdApi appid_api;
Packet::Packet(bool) { }
-Packet::~Packet() { }
+Packet::~Packet() = default;
Packet* DetectionEngine::get_current_packet()
{
mock_session->create_http_session();
flow->set_flow_data(mock_session);
appidDebug = new AppIdDebug();
- appidDebug->activate(nullptr, nullptr, 0);
+ appidDebug->activate(nullptr, nullptr, false);
}
void teardown() override
OdpContext::OdpContext(const AppIdConfig&, snort::SnortConfig*) { }
-AppIdConfig::~AppIdConfig() { }
+AppIdConfig::~AppIdConfig() = default;
unsigned AppIdSession::inspector_id = 0;
THREAD_LOCAL AppIdDebug* appidDebug = nullptr;
void LogLabel(const char*, FILE*) {}
SearchTool::SearchTool(char const*, bool) { }
-SearchTool::~SearchTool() { }
+SearchTool::~SearchTool() = default;
}
void ApplicationDescriptor::set_id(AppId app_id){ my_id = app_id;}
void ClientAppDescriptor::update_stats(AppId, bool) {}
void PayloadAppDescriptor::update_stats(AppId, bool) {}
-AppIdDiscovery::~AppIdDiscovery() { }
+AppIdDiscovery::~AppIdDiscovery() = default;
void ClientDiscovery::initialize(AppIdInspector&) { }
void ClientDiscovery::reload() { }
void AppIdDiscovery::register_detector(const string&, AppIdDetector*, IpProtocol) { }
void AppIdDiscovery::register_tcp_pattern(AppIdDetector*, unsigned char const*, unsigned int, int, unsigned int) { }
void AppIdDiscovery::register_udp_pattern(AppIdDetector*, unsigned char const*, unsigned int, int, unsigned int) { }
int AppIdDiscovery::add_service_port(AppIdDetector*, ServiceDetectorPort const&) { return 0; }
-DnsPatternMatchers::~DnsPatternMatchers() { }
-HttpPatternMatchers::~HttpPatternMatchers() { }
-SipPatternMatchers::~SipPatternMatchers() { }
-SslPatternMatchers::~SslPatternMatchers() { }
+DnsPatternMatchers::~DnsPatternMatchers() = default;
+HttpPatternMatchers::~HttpPatternMatchers() = default;
+SipPatternMatchers::~SipPatternMatchers() = default;
+SslPatternMatchers::~SslPatternMatchers() = default;
void Field::set(int32_t length, const uint8_t* start, bool own_the_buffer_)
{
return 0;
}
-FlowStash::~FlowStash() { }
+FlowStash::~FlowStash() = default;
#endif
}
AppIdModule::AppIdModule(): snort::Module("appid_mock", "appid_mock_help") {}
-AppIdModule::~AppIdModule() {}
+AppIdModule::~AppIdModule() = default;
void AppIdModule::sum_stats(bool) {}
void AppIdModule::show_dynamic_stats() {}
bool AppIdModule::begin(char const*, int, snort::SnortConfig*) { return true; }
void AppIdModule::set_trace(const Trace*) const { }
const TraceOption* AppIdModule::get_trace_options() const { return nullptr; }
-AppIdInspector::~AppIdInspector() { }
+AppIdInspector::~AppIdInspector() = default;
void AppIdInspector::eval(snort::Packet*) { }
bool AppIdInspector::configure(snort::SnortConfig*) { return true; }
void AppIdInspector::show(const SnortConfig*) const { }
}
};
-AppIdConfig::~AppIdConfig() { }
+AppIdConfig::~AppIdConfig() = default;
OdpContext::OdpContext(const AppIdConfig&, snort::SnortConfig*) { }
void FlowHAState::add(uint8_t) { }
memcpy(p, str, n);
return p;
}
-time_t packet_time() { return std::time(0); }
+time_t packet_time() { return std::time(nullptr); }
AppIdSessionApi::AppIdSessionApi(const AppIdSession*, const SfIp&) :
StashGenericObject(STASH_GENERIC_OBJECT_APPID) {}
void ClientAppDescriptor::update_user(AppId, const char*, AppidChangeBits&){}
void ClientAppDescriptor::update_stats(AppId, bool) {}
void PayloadAppDescriptor::update_stats(AppId, bool) {}
-AppIdConfig::~AppIdConfig() { }
+AppIdConfig::~AppIdConfig() = default;
OdpContext::OdpContext(const AppIdConfig&, snort::SnortConfig*) { }
AppIdConfig stub_config;
AppIdContext stub_ctxt(stub_config);
OdpContext&, uint16_t) : FlowData(0), config(stub_config),
api(*(new AppIdSessionApi(this, *ip))), odp_ctxt(stub_odp_ctxt) { }
AppIdSession::~AppIdSession() = default;
-AppIdDiscovery::~AppIdDiscovery() {}
+AppIdDiscovery::~AppIdDiscovery() = default;
void ClientDiscovery::initialize(AppIdInspector&) { }
void ClientDiscovery::reload() { }
void AppIdDiscovery::register_detector(const std::string&, AppIdDetector*, IpProtocol) {}
AppidChangeBits&) { return 0; }
int ServiceDiscovery::add_ftp_service_state(AppIdSession&) { return 0; }
bool ServiceDiscovery::do_service_discovery(AppIdSession&, Packet*, AppidSessionDirection,
- AppidChangeBits&) { return 0; }
+ AppidChangeBits&) { return false; }
int ServiceDiscovery::incompatible_data(AppIdSession&, const Packet*,AppidSessionDirection,
ServiceDetector*) { return 0; }
int ServiceDiscovery::fail_service(AppIdSession&, const Packet*, AppidSessionDirection,
ServiceDetector*, ServiceDiscoveryState*) { return 0; }
int ServiceDiscovery::add_service_port(AppIdDetector*,
const ServiceDetectorPort&) { return APPID_EINVALID; }
-DnsPatternMatchers::~DnsPatternMatchers() { }
-HttpPatternMatchers::~HttpPatternMatchers() { }
-SipPatternMatchers::~SipPatternMatchers() { }
-SslPatternMatchers::~SslPatternMatchers() { }
+DnsPatternMatchers::~DnsPatternMatchers() = default;
+HttpPatternMatchers::~HttpPatternMatchers() = default;
+SipPatternMatchers::~SipPatternMatchers() = default;
+SslPatternMatchers::~SslPatternMatchers() = default;
snort::SearchTool::SearchTool(char const*, bool) { }
-snort::SearchTool::~SearchTool() { }
+snort::SearchTool::~SearchTool() = default;
TEST_GROUP(service_state_tests)
{
void setup() override
{
appidDebug = new AppIdDebug();
- appidDebug->activate(nullptr, nullptr, 0);
+ appidDebug->activate(nullptr, nullptr, false);
}
void teardown() override
// Testing 3+ failures to exceed STATE_ID_NEEDED_DUPE_DETRACT_COUNT with valid_count > 1
sds.set_state(ServiceState::VALID);
- sds.set_service_id_valid(0);
- sds.set_service_id_valid(0);
+ sds.set_service_id_valid(nullptr);
+ sds.set_service_id_valid(nullptr);
sds.set_service_id_failed(asd, &client_ip, 0);
sds.set_service_id_failed(asd, &client_ip, 0);
sds.set_service_id_failed(asd, &client_ip, 0);
IpProtocol proto = IpProtocol::TCP;
uint16_t port=3000;
- AppIdServiceStateKey A(&ip4, proto, port, 0, DAQ_PKTHDR_UNKNOWN, 0);
- AppIdServiceStateKey B(&ip6, proto, port, 0, DAQ_PKTHDR_UNKNOWN, 0);
+ AppIdServiceStateKey A(&ip4, proto, port, 0, DAQ_PKTHDR_UNKNOWN, false);
+ AppIdServiceStateKey B(&ip6, proto, port, 0, DAQ_PKTHDR_UNKNOWN, false);
// We must never be in a situation where !( A<B ) and !( B<A ),
// because then map will consider A=B.
for( size_t i = 1; i <= num_entries; i++, port++ )
{
const SfIp* ip = ( i%2 == 1 ? &ip4 : &ip6 );
- ss = ServiceCache.add( AppIdServiceStateKey(ip, proto, port, 0, DAQ_PKTHDR_UNKNOWN, 0) );
+ ss = ServiceCache.add( AppIdServiceStateKey(ip, proto, port, 0, DAQ_PKTHDR_UNKNOWN, false) );
CHECK_TRUE(ServiceCache.size() == ( i <= max_entries ? i : max_entries));
ssvec.push_back(ss);
}
ThirdPartyAppIdContext* AppIdContext::tp_appid_ctxt = nullptr;
snort::SearchTool::SearchTool(char const*, bool) { }
-snort::SearchTool::~SearchTool() { }
+snort::SearchTool::~SearchTool() = default;
-AppIdDiscovery::~AppIdDiscovery() { }
+AppIdDiscovery::~AppIdDiscovery() = default;
void ClientDiscovery::initialize(AppIdInspector&) { }
void ClientDiscovery::reload() { }
void AppIdDiscovery::register_detector(const string&, AppIdDetector*, IpProtocol) { }
void AppIdDiscovery::register_tcp_pattern(AppIdDetector*, unsigned char const*, unsigned int, int, unsigned int) { }
void AppIdDiscovery::register_udp_pattern(AppIdDetector*, unsigned char const*, unsigned int, int, unsigned int) { }
int AppIdDiscovery::add_service_port(AppIdDetector*, ServiceDetectorPort const&) { return 0; }
-DnsPatternMatchers::~DnsPatternMatchers() { }
-HttpPatternMatchers::~HttpPatternMatchers() { }
-SipPatternMatchers::~SipPatternMatchers() { }
-SslPatternMatchers::~SslPatternMatchers() { }
-AppIdConfig::~AppIdConfig() { }
+DnsPatternMatchers::~DnsPatternMatchers() = default;
+HttpPatternMatchers::~HttpPatternMatchers() = default;
+SipPatternMatchers::~SipPatternMatchers() = default;
+SslPatternMatchers::~SslPatternMatchers() = default;
+AppIdConfig::~AppIdConfig() = default;
OdpContext::OdpContext(const AppIdConfig&, snort::SnortConfig*) { }
void ServiceDiscovery::initialize(AppIdInspector&) { }
void ServiceDiscovery::reload() { }
return version;
}
- virtual ~ThirdPartyAppIdContext() { }
+ virtual ~ThirdPartyAppIdContext() = default;
uint32_t get_api_version() const { return api_version; }
const std::string& module_name() const { return name; }
{
ctxt_version = ctxt.get_version();
}
- virtual ~ThirdPartyAppIdSession() { }
+ virtual ~ThirdPartyAppIdSession() = default;
virtual void reset() = 0; // just reset state
virtual void delete_with_ctxt() = 0;
// FIXIT-L: make these private too. Figure out how these get set in tp.
public:
- ThirdPartyAppIDAttributeData() { }
+ ThirdPartyAppIDAttributeData() = default;
~ThirdPartyAppIDAttributeData()
{
AppIdHttpSession* hsession = asd.get_http_session(0);
if (!hsession)
hsession = asd.create_http_session();
- string* field=0;
+ string* field=nullptr;
bool own=true;
hsession->reset_ptype_scan_counts();
bool own = true;
uint16_t size = 0;
- const string* field=0;
+ const string* field=nullptr;
if ( !hsession->get_field(MISC_URL_FID) )
{
{
AppId tmpAppId = APP_ID_NONE;
int tmpConfidence = 0;
- const string* field = 0;
+ const string* field = nullptr;
int reinspect_ssl_appid = 0;
if (asd.get_session_flags(APPID_SESSION_HTTP_TUNNEL))
static inline void process_ftp_control(AppIdSession& asd,
ThirdPartyAppIDAttributeData& attribute_data, AppidChangeBits& change_bits)
{
- const string* field=0;
+ const string* field=nullptr;
if (!asd.get_odp_ctxt().ftp_userid_disabled &&
(field=attribute_data.ftp_command_user()) != nullptr)
{
static inline void process_quic(AppIdSession& asd,
ThirdPartyAppIDAttributeData& attribute_data, AppidChangeBits& change_bits)
{
- const string* field = 0;
+ const string* field = nullptr;
if ( !asd.tsession )
asd.tsession = new TlsSession();
list_item->intfs.clear();
- while ((token = strtok_r(next_ptr, MANIFEST_SEPARATORS, &next_ptr)) != NULL)
+ while ((token = strtok_r(next_ptr, MANIFEST_SEPARATORS, &next_ptr)) != nullptr)
{
char* end_str;
long intf_id;
uint16_t max_payloads = 100;
uint16_t max_host_services = 100;
uint16_t max_host_service_info = 16;
- bool enable_banner_grab = 0;
- bool log_when_idle = 0;
+ bool enable_banner_grab = false;
+ bool log_when_idle = false;
};
#endif
std::string fpuuid;
uint8_t ttl = 0;
- virtual ~FpFingerprint() { }
+ virtual ~FpFingerprint() = default;
virtual void clear()
{
/* build a key for the lookup */
if (p->is_ip6())
- fpk.isIpv6 = 1;
+ fpk.isIpv6 = true;
else if (p->ptrs.ip_api.get_ip4h()->df())
fpk.df = true;
get_tcp_option(p, tcp::TcpOptCode::SACKOK, fpk.sackok_pos);
fpk.ws = get_tcp_option(p, tcp::TcpOptCode::WSCALE, fpk.ws_pos);
get_tcp_option(p, tcp::TcpOptCode::TIMESTAMP, fpk.timestamp_pos);
- mssOptionPresent = 1;
+ mssOptionPresent = true;
}
TCP_FP_MODE traffic_source = p->ptrs.tcph->is_ack() ? TCP_FP_MODE::SERVER : TCP_FP_MODE::CLIENT;
rawfp.id = "X";
rawfp.topts = "2 3 4 8";
rawfp.ws = "6";
- rawfp.df = 1;
+ rawfp.df = true;
TcpFingerprint tfp(rawfp);
tfp.clear();
rawfp.id = "X";
rawfp.topts = "2 3 4 8";
rawfp.ws = "6";
- rawfp.df = 1;
+ rawfp.df = true;
TcpFingerprint tfpe;
tfpe.fpid = rawfp.fpid;
rawfp.id = "X";
rawfp.topts = "2 3 4 8";
rawfp.ws = "6";
- rawfp.df = 1;
+ rawfp.df = true;
processor->push(rawfp);
TcpFingerprint f948(rawfp);
rawfp.id = "X";
rawfp.topts = "2 4 8 3";
rawfp.ws = "8";
- rawfp.df = 1;
+ rawfp.df = true;
processor->push(rawfp);
TcpFingerprint f30962(rawfp);
rawfp.id = "X";
rawfp.topts = "2 4 8 3";
rawfp.ws = "7";
- rawfp.df = 0;
+ rawfp.df = false;
processor->push(rawfp);
TcpFingerprint f110005(rawfp);
rawfp.id = "X";
rawfp.topts = "2 4 8 3";
rawfp.ws = "7";
- rawfp.df = 0;
+ rawfp.df = false;
processor->push(rawfp);
TcpFingerprint f120001(rawfp);
rawfp.id = "X";
rawfp.topts = "2";
rawfp.ws = "0-1";
- rawfp.df = 0;
+ rawfp.df = false;
processor->push(rawfp);
TcpFingerprint f2(rawfp);
key.sackok_pos = 1; // SACKOK = 4 in position 1
key.timestamp_pos = 2; // TIMESTAMP = 8 in position 2
key.ws_pos = 3; // WSCALE = 3 in position 3
- key.df = 0;
- key.isIpv6 = 1;
+ key.df = false;
+ key.isIpv6 = true;
syn_tcpopts[key.mss_pos] = (uint8_t) tcp::TcpOptCode::MAXSEG;
syn_tcpopts[key.timestamp_pos] = (uint8_t) tcp::TcpOptCode::TIMESTAMP;
syn_tcpopts[key.sackok_pos] = (uint8_t) tcp::TcpOptCode::SACKOK;
key.sackok_pos = 1; // SACKOK = 4 in position 1
key.timestamp_pos = 2; // TIMESTAMP = 8 in position 2
key.ws_pos = 3; // WSCALE = 3 in position 3
- key.df = 1;
- key.isIpv6 = 0;
+ key.df = true;
+ key.isIpv6 = false;
syn_tcpopts[key.mss_pos] = (uint8_t) tcp::TcpOptCode::MAXSEG;
syn_tcpopts[key.timestamp_pos] = (uint8_t) tcp::TcpOptCode::TIMESTAMP;
syn_tcpopts[key.sackok_pos] = (uint8_t) tcp::TcpOptCode::SACKOK;
#include "rna_module.h"
#include <cassert>
+#include <cstring>
#include <fstream>
#include <iomanip>
#include <sstream>
-#include <string.h>
#include <sys/stat.h>
#include "host_tracker/host_cache.h"
if ( !outfile )
{
LogMessage("File name is needed!\n");
- return 0;
+ return false;
}
struct stat file_stat;
if ( stat(outfile, &file_stat) == 0 )
{
LogMessage("File %s already exists!\n", outfile);
- return 0;
+ return false;
}
ofstream out_stream(outfile);
}
out_stream.close();
- return 0;
+ return false;
}
bool RnaModule::is_valid_fqn(const char* fqn) const
update_timeout = (rc ? rc->update_timeout : 0);
}
-RnaPnd::~RnaPnd()
-{ }
+RnaPnd::~RnaPnd() = default;
void RnaPnd::analyze_appid_changes(DataEvent& event)
{
void LogMessage(const char*,...) {}
void WarningMessage(const char*,...) {}
SnortConfig::SnortConfig(SnortConfig const*) {}
-SnortConfig::~SnortConfig() {}
+SnortConfig::~SnortConfig() = default;
time_t packet_time() { return 0; }
// tcp fingerprint functions
TcpFingerprint::TcpFingerprint(const RawFingerprint&) { }
bool TcpFingerprint::operator==(const TcpFingerprint&) const { return true; }
-UaFpProcessor::~UaFpProcessor() { }
+UaFpProcessor::~UaFpProcessor() = default;
void UaFpProcessor::make_mpse(SnortConfig*) { }
void UaFpProcessor::push(RawFingerprint const&) { }
HostCacheMac* get_host_cache_mac() { return nullptr; }
-DataPurgeAC::~DataPurgeAC() { }
+DataPurgeAC::~DataPurgeAC() = default;
bool DataPurgeAC::execute(Analyzer&, void**) { return true;}
void snort::main_broadcast_command(AnalyzerCommand*, bool) { }
rawfp.id = "X";
rawfp.topts = "2 3 4 8";
rawfp.ws = "6";
- rawfp.df = 1;
+ rawfp.df = true;
// expected
TcpFingerprint tfpe;
#include "parse_conf.h"
-#include <limits.h>
#include <sys/stat.h>
#include <unistd.h>
+#include <climits>
#include <fstream>
#include <stack>
class SoRuleParser
{
public:
- SoRuleParser() { }
+ SoRuleParser() = default;
bool parse_so_rule(const char* in, std::string& stub, std::string& opts);
flow_state = Flow::FlowState::SETUP;
}
-Flow::~Flow() { }
+Flow::~Flow() = default;
IpsContext::IpsContext(unsigned int) { }
-IpsContext::~IpsContext() { }
+IpsContext::~IpsContext() = default;
SnortConfig::SnortConfig(snort::SnortConfig const*) { }
-SnortConfig::~SnortConfig() { }
+SnortConfig::~SnortConfig() = default;
IpsContext ips_context;
SnortConfig conf;
static void set_not_configured() { conf.payload_injector_config = nullptr; }
static void set_configured() { conf.payload_injector_config = &pi_conf; }
-Packet::~Packet() { }
+Packet::~Packet() = default;
int DetectionEngine::queue_event(unsigned int, unsigned int, snort::Actions::Type) { return 0; }
-FlowData::~FlowData() { }
+FlowData::~FlowData() = default;
FlowData::FlowData(unsigned int, snort::Inspector*) { }
// Inspector mocks, used by MockInspector class
{
public:
- MockInspector() { }
- ~MockInspector() override { }
+ MockInspector() = default;
+ ~MockInspector() override = default;
void eval(snort::Packet*) override { }
bool configure(snort::SnortConfig*) override { return true; }
};
// Mocks for snort::Flow::get_flow_data
unsigned Http2FlowData::inspector_id = 0;
-Http2Stream::~Http2Stream() { }
-HpackDynamicTable::~HpackDynamicTable() { }
+Http2Stream::~Http2Stream() = default;
+HpackDynamicTable::~HpackDynamicTable() = default;
Http2DataCutter::Http2DataCutter(Http2FlowData* _session_data, HttpCommon::SourceId src_id) :
session_data(_session_data), source_id(src_id) { }
Http2FlowData::Http2FlowData(snort::Flow*) :
},
data_cutter {Http2DataCutter(this, SRC_CLIENT), Http2DataCutter(this, SRC_SERVER)}
{ }
-Http2FlowData::~Http2FlowData() { }
+Http2FlowData::~Http2FlowData() = default;
Http2FlowData http2_flow_data(nullptr);
void Http2FlowData::set_mid_frame(bool val) { continuation_expected[SRC_SERVER] = val; }
bool Http2FlowData::is_mid_frame() const { return continuation_expected[SRC_SERVER]; }
{
PortObject2* po = (PortObject2*)snort_calloc(sizeof(PortObject2));
po->item_list = sflist_new();
- po->rule_hash = new GHash(nrules, sizeof(int), 0, snort_free);
+ po->rule_hash = new GHash(nrules, sizeof(int), false, snort_free);
po->rule_hash->set_hashkey_ops(new PortObject2HashKeyOps(nrules));
return po;
PortObject** pol = upA.get();
// Create a Merged Port Object Table - hash by ports, no user keys, don't free data
- GHash* mhash = new GHash(PO_HASH_TBL_ROWS, sizeof(PortObject*), 0, nullptr);
+ GHash* mhash = new GHash(PO_HASH_TBL_ROWS, sizeof(PortObject*), false, nullptr);
mhash->set_hashkey_ops(new PortObjectHashKeyOps(PO_HASH_TBL_ROWS));
p->pt_mpo_hash = mhash;
// Create a Merged Port Object Table - hash by pointers, no user keys, don't free data
- GHash* mhashx = new GHash(PO_HASH_TBL_ROWS, sizeof(plx_t*), 0, nullptr);
+ GHash* mhashx = new GHash(PO_HASH_TBL_ROWS, sizeof(plx_t*), false, nullptr);
mhashx->set_hashkey_ops(new PlxHashKeyOps(PO_HASH_TBL_ROWS));
p->pt_mpxo_hash = mhashx;
* so 1000 entries is ok, worst that happens is somewhat slower
* config/rule processing.
*/
- GHash* h = new GHash(1000, 0, 0, PortObjectFree);
+ GHash* h = new GHash(1000, 0, false, PortObjectFree);
PortObject* po = PortObjectNew(); // Create default port objects
PortObjectAddPortAny(po); // Default has an ANY port
PortVarTableAdd(h, po); // Add ANY to the table
};
DataDecryptEvent(const StateEventType& type) : m_type(type) { }
- StateEventType get_type(void) const { return m_type; }
+ StateEventType get_type() const { return m_type; }
private:
StateEventType m_type;
#include "config.h"
#endif
-#include <string.h>
+#include <cstring>
#include "framework/base_api.h"
#include "framework/counts.h"
#include "search_engines/search_tool.h"
#undef private
-#include <string.h>
+#include <cstring>
#include "detection/fp_config.h"
#include "framework/base_api.h"
#include "cip_session.h"
-#include <math.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <string.h>
#include <sys/time.h>
+
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+
#include "time/timersub.h" // For TIMERSUB
#include "cip_parsing.h" // For CIP constants
static CipConnection* cip_find_connection_slot(CipConnectionList* connection_list,
const struct timeval* timestamp)
{
- CipConnection* connection = NULL;
+ CipConnection* connection = nullptr;
// Prune old connections if the list is at max capacity.
if (connection_list->count == connection_list->list_size)
uint32_t connection_id,
bool established)
{
- CipConnection* connection = NULL;
+ CipConnection* connection = nullptr;
for (uint32_t i = 0; i < connection_list->list_size; ++i)
{
uint32_t ot_connection_id,
uint32_t to_connection_id)
{
- const CipConnection* connection = NULL;
+ const CipConnection* connection = nullptr;
for (uint32_t i = 0; i < connection_list->list_size; ++i)
{
static const CipConnection* cip_find_connection_any(const CipConnectionList* connection_list,
const CipConnectionSignature* signature)
{
- const CipConnection* connection = NULL;
+ const CipConnection* connection = nullptr;
for (uint32_t i = 0; i < connection_list->list_size; ++i)
{
const CipConnectionSignature* signature,
bool established)
{
- CipConnection* connection = NULL;
+ CipConnection* connection = nullptr;
for (uint32_t i = 0; i < connection_list->list_size; ++i)
{
CipUnconnectedMessageList* unconnected_list,
const struct timeval* timestamp)
{
- CipUnconnectedMessage* unconnected_message = NULL;
+ CipUnconnectedMessage* unconnected_message = nullptr;
// Prune old messages if the list is at max capacity.
if (unconnected_list->count == unconnected_list->list_size)
CipUnconnectedMessageList* unconnected_list,
uint64_t sender_context)
{
- CipUnconnectedMessage* unconnected_message = NULL;
+ CipUnconnectedMessage* unconnected_message = nullptr;
for (uint32_t i = 0; i < unconnected_list->list_size; ++i)
{
#ifndef CIP_SESSION_H
#define CIP_SESSION_H
-#include <stdbool.h>
-#include <stdint.h>
+#include <cstdint>
+
#include "main/snort_config.h"
#include "main/snort_types.h"
{
public:
- DCE2_DbMap() { }
+ DCE2_DbMap() = default;
~DCE2_DbMap()
{
"SMB2_COM_SET_INFO",
"SMB2_COM_OPLOCK_BREAK"};
-static inline SmbFlowKey get_flow_key(void)
+static inline SmbFlowKey get_flow_key()
{
SmbFlowKey key;
const FlowKey* flow_key = DetectionEngine::get_current_packet()->flow->key;
memory::MemoryCap::update_allocations(sizeof(*this));
}
-DCE2_Smb2FileTracker::~DCE2_Smb2FileTracker(void)
+DCE2_Smb2FileTracker::~DCE2_Smb2FileTracker()
{
debug_logf(dce_smb_trace, nullptr,
"file tracker %" PRIu64 " file name hash %" PRIu64 " terminating\n",
memory::MemoryCap::update_allocations(sizeof(*this));
}
-DCE2_Smb2TreeTracker::~DCE2_Smb2TreeTracker(void)
+DCE2_Smb2TreeTracker::~DCE2_Smb2TreeTracker()
{
debug_logf(dce_smb_trace, nullptr, "tree tracker %" PRIu32 " terminating\n", tid);
memory::MemoryCap::update_allocations(sizeof(*this));
}
-DCE2_Smb2SessionTracker::~DCE2_Smb2SessionTracker(void)
+DCE2_Smb2SessionTracker::~DCE2_Smb2SessionTracker()
{
debug_logf(dce_smb_trace, nullptr, "session tracker %" PRIu64 " terminating\n", session_id);
removeSessionFromAllConnection();
SmbSessionCache_map(const size_t initial_size) : LruCacheShared<Key, Value, Hash>(initial_size)
{
}
- virtual ~SmbSessionCache_map() { }
+ ~SmbSessionCache_map() override = default;
};
typedef SmbSessionCache_map<Smb2SidHashKey, DCE2_Smb2SessionTracker, SmbKeyHash> SmbSessionCache;
if (!iError)
{
- return NULL;
+ return nullptr;
}
if (!BounceLookup)
{
*iError = FTPP_INVALID_ARG;
- return NULL;
+ return nullptr;
}
*iError = FTPP_SUCCESS;
if (!iError)
{
- return NULL;
+ return nullptr;
}
if (!BounceLookup)
{
*iError = FTPP_INVALID_ARG;
- return NULL;
+ return nullptr;
}
*iError = FTPP_SUCCESS;
class Http2DataFrame : public Http2Frame
{
public:
- ~Http2DataFrame() override {}
+ ~Http2DataFrame() override = default;
bool valid_sequence(Http2Enums::StreamState state) override;
void analyze_http1() override;
void clear() override;
class Http2Frame
{
public:
- virtual ~Http2Frame() { }
+ virtual ~Http2Frame() = default;
static Http2Frame* new_frame(const uint8_t* header_buffer, const uint32_t header_len,
const uint8_t* data_buffer, const uint32_t data_len, Http2FlowData* session_data,
HttpCommon::SourceId source_id, Http2Stream* stream);
#include "http2_hpack_dynamic_table.h"
#include "http2_module.h"
-#include <string.h>
+#include <cstring>
#include "http2_hpack_table.h"
#include "http2_enum.h"
#include "http2_huffman_state_machine.h"
-#include <math.h>
+#include <cmath>
using namespace Http2Enums;
#include "http2_flow_data.h"
#include "http2_hpack_table.h"
-#include <string.h>
+#include <cstring>
#define MAKE_TABLE_ENTRY(name, value) \
HpackTableEntry(strlen(name), (const uint8_t*)name, strlen(value), (const uint8_t*)value)
#include "http2_request_line.h"
-#include <string.h>
#include <cstdlib>
+#include <cstring>
#include "service_inspectors/http_inspect/http_common.h"
#include "service_inspectors/http_inspect/http_field.h"
#ifndef IEC104_PARSE_APCI_H
#define IEC104_PARSE_APCI_H
-#include <stdint.h>
+#include <cstdint>
void parseIec104ApciU(const struct Iec104ApciU* apci);
void parseIec104ApciS(const struct Iec104ApciS* apci);
config->decode_conf.sync_all_depths();
if (config->decode_conf.get_file_depth() > -1)
- config->log_config.log_filename = 1;
+ config->log_config.log_filename = true;
IMAP_SearchInit();
return true;
config->decode_conf.sync_all_depths();
if (config->decode_conf.get_file_depth() > -1)
- config->log_config.log_filename = 1;
+ config->log_config.log_filename = true;
POP_SearchInit();
return true;
#include "sip_splitter.h"
-#include <ctype.h>
-#include <string.h>
+#include <cctype>
+#include <cstring>
using namespace snort;
config->decode_conf.sync_all_depths();
if (config->decode_conf.get_file_depth() > -1)
- config->log_config.log_filename = 1;
+ config->log_config.log_filename = true;
SMTP_ResponseSearchInit();
SMTP_CommandSearchInit(config);
// Setup
MailLogConfig log_config;
DecodeConfig decode_conf;
- log_config.log_email_hdrs = 0;
+ log_config.log_email_hdrs = false;
SmtpMime mime_ssn(&decode_conf, &log_config);
smtp_normalizing = true;
SmtpProtoConf config;
class StreamReloadResourceManager : public snort::ReloadResourceTuner
{
public:
- StreamReloadResourceManager() {}
+ StreamReloadResourceManager() = default;
bool tinit() override;
bool tune_packet_context() override;
class StreamUnloadReloadResourceManager : public snort::ReloadResourceTuner
{
public:
- StreamUnloadReloadResourceManager() { }
+ StreamUnloadReloadResourceManager() = default;
bool tinit() override;
bool tune_packet_context() override;
class SegmentOverlapEditor
{
protected:
- SegmentOverlapEditor() { }
+ SegmentOverlapEditor() = default;
virtual ~SegmentOverlapEditor() = default;
void eval_left(TcpReassemblerState&);
: Session(f), client(true), server(false)
{ }
-TcpStreamSession::~TcpStreamSession()
-{ }
+TcpStreamSession::~TcpStreamSession() = default;
void TcpStreamSession::init_new_tcp_session(TcpSegmentDescriptor& tsd)
{
};
TcpSession::TcpSession( Flow* ) : Session( flow ) { }
-TcpSession::~TcpSession( void ) { }
+TcpSession::~TcpSession() = default;
bool TcpSession::setup(Packet*){ return true; }
void TcpSession::update_direction(char, SfIp const*, unsigned short){ }
int TcpSession::process(Packet*){ return 0; }
{
public:
TcpSessionMock( Flow* flow ) : TcpSession( flow ), client( true ), server( false ) { }
- ~TcpSessionMock( void ) { }
+ ~TcpSessionMock() = default;
TcpStreamTracker client;
TcpStreamTracker server;
Flow::Flow() = default;
Packet::Packet(bool) { }
-Packet::~Packet() { }
+Packet::~Packet() = default;
struct Packet* DetectionEngine::get_current_packet()
{ return nullptr; }
Module(name, "trace_test_help"), test_trace_options(trace_options)
{ }
- virtual const TraceOption* get_trace_options() const
+ const TraceOption* get_trace_options() const override
{ return test_trace_options; }
private:
void update_option(const std::string& keyword, const std::string& val);
void add_suboption(const std::string& keyword);
void add_suboption(const std::string& keyword, const std::string& val);
- void reset_sticky(void);
+ void reset_sticky();
void set_curr_options_buffer(const std::string& buffer, bool add_option);
void update_rule_action(const std::string&);
void set_rule_old_action(const std::string&);
DataApi::developer_error("Add some header data before adding content!!");
}
-void RuleApi::reset_sticky(void)
+void RuleApi::reset_sticky()
{
if (curr_rule)
curr_rule->reset_sticky();
void update_option(const std::string& keyword, const std::string& val);
void add_suboption(const std::string& keyword);
void add_suboption(const std::string& keyword, const std::string& val);
- void reset_sticky(void);
+ void reset_sticky();
void set_curr_options_buffer(const std::string& buffer, bool add_option=false);
void set_rule_old_action(const std::string&);
std::string& get_rule_old_action();
projects / thirdparty / snort3.git / commitdiff
