class DecodeModule : public Module
{
public:
- using Module::Module; // inherit Module's constructors
+ DecodeModule(const char* s) : Module(s)
+ { };
+
+ DecodeModule(const char* s, const Parameter* p, bool is_list = false)
+ : Module(s, p, is_list) { };
unsigned get_gid() const
{ return GID_DECODE; };
#include "codecs/ip/cd_auth_module.h"
-
-static const Parameter ah_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap ah_rules[] =
{
{ DECODE_AUTH_HDR_TRUNC, "(" CD_AUTH_NAME ") Truncated authentication header"},
};
//-------------------------------------------------------------------------
-// rpc module
+// auth module
//-------------------------------------------------------------------------
-AhModule::AhModule() : DecodeModule(CD_AUTH_NAME, ah_params, ah_rules)
+AhModule::AhModule() : DecodeModule(CD_AUTH_NAME)
{ }
-bool AhModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* AhModule::get_rules() const
+{ return ah_rules; }
+
public:
AhModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_esp_module.h"
#include "main/snort_config.h"
-
static const Parameter esp_params[] =
{
{ "decode_esp", Parameter::PT_BOOL, nullptr, "false",
// rpc module
//-------------------------------------------------------------------------
-EspModule::EspModule() : DecodeModule(CD_ESP_NAME, esp_params, esp_rules)
+EspModule::EspModule() : DecodeModule(CD_ESP_NAME, esp_params)
{ }
+const RuleMap* EspModule::get_rules() const
+{ return esp_rules; }
+
bool EspModule::set(const char*, Value& v, SnortConfig* sc)
{
if ( v.is("decode_esp") )
return true;
}
-
public:
EspModule();
+ const RuleMap* get_rules() const;
bool set(const char*, Value&, SnortConfig*);
};
#include "codecs/ip/cd_gre_module.h"
-
-static const Parameter gre_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap gre_rules[] =
{
{ DECODE_GRE_DGRAM_LT_GREHDR, "(" CD_GRE_NAME ") GRE header length > payload length" },
// rpc module
//-------------------------------------------------------------------------
-GreModule::GreModule() : DecodeModule(CD_GRE_NAME, gre_params, gre_rules)
+GreModule::GreModule() : DecodeModule(CD_GRE_NAME)
{ }
-bool GreModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* GreModule::get_rules() const
+{ return gre_rules; }
+
public:
GreModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_icmp4_module.h"
-
-static const Parameter icmp4_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
// rules which will loaded into snort.
// You can now reference these rules by calling a codec_event
// in your main codec's functions
// rpc module
//-------------------------------------------------------------------------
-Icmp4Module::Icmp4Module() : DecodeModule(CD_ICMP4_NAME, icmp4_params, icmp4_rules)
+Icmp4Module::Icmp4Module() : DecodeModule(CD_ICMP4_NAME)
{ }
-bool Icmp4Module::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* Icmp4Module::get_rules() const
+{ return icmp4_rules; }
+
public:
Icmp4Module();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_icmp6_module.h"
-
-static const Parameter icmp6_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
// rules which will loaded into snort.
// You can now reference these rules by calling a codec_event
// in your main codec's functions
// rpc module
//-------------------------------------------------------------------------
-Icmp6Module::Icmp6Module() : DecodeModule(CD_ICMP6_NAME, icmp6_params, icmp6_rules)
+Icmp6Module::Icmp6Module() : DecodeModule(CD_ICMP6_NAME)
{ }
-bool Icmp6Module::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* Icmp6Module::get_rules() const
+{ return icmp6_rules; }
+
public:
Icmp6Module();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_igmp_module.h"
-
-static const Parameter igmp_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap igmp_rules[] =
{
{ DECODE_IGMP_OPTIONS_DOS, "(" CD_IGMP_NAME ") DOS IGMP IP Options validation attempt" },
// rpc module
//-------------------------------------------------------------------------
-IgmpModule::IgmpModule() : DecodeModule(CD_IGMP_NAME, igmp_params, igmp_rules)
+IgmpModule::IgmpModule() : DecodeModule(CD_IGMP_NAME)
{ }
-bool IgmpModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* IgmpModule::get_rules() const
+{ return igmp_rules; }
+
public:
IgmpModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_ipv4_module.h"
-
-static const Parameter ipv4_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
// rules which will loaded into snort.
// You can now reference these rules by calling a codec_event
// in your main codec's functions
// rpc module
//-------------------------------------------------------------------------
-Ipv4Module::Ipv4Module() : DecodeModule(CD_IPV4_NAME, ipv4_params, ipv4_rules)
+Ipv4Module::Ipv4Module() : DecodeModule(CD_IPV4_NAME)
{ }
-bool Ipv4Module::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
-
+const RuleMap* Ipv4Module::get_rules() const
+{ return ipv4_rules; }
public:
Ipv4Module();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
// rpc module
//-------------------------------------------------------------------------
-Ipv6Module::Ipv6Module() : DecodeModule(CD_IPV6_NAME, ipv6_params, ipv6_rules)
+Ipv6Module::Ipv6Module() : DecodeModule(CD_IPV6_NAME, ipv6_params)
{ }
-bool Ipv6Module::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* Ipv6Module::get_rules() const
+{ return ipv6_rules; }
+
public:
Ipv6Module();
- bool set(const char*, Value&, SnortConfig*);
-
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_pgm_module.h"
-
-static const Parameter pgm_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap pgm_rules[] =
{
{ DECODE_PGM_NAK_OVERFLOW, "(" CD_PGM_NAME ") BAD-TRAFFIC PGM nak list overflow attempt" },
// rpc module
//-------------------------------------------------------------------------
-PgmModule::PgmModule() : DecodeModule(CD_PGM_NAME, pgm_params, pgm_rules)
+PgmModule::PgmModule() : DecodeModule(CD_PGM_NAME)
{ }
-bool PgmModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* PgmModule::get_rules() const
+{ return pgm_rules; }
+
public:
PgmModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/ip/cd_tcp_module.h"
-
-static const Parameter tcp_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
// rules which will loaded into snort.
// You can now reference these rules by calling a codec_event
// in your main codec's functions
// rpc module
//-------------------------------------------------------------------------
-TcpModule::TcpModule() : DecodeModule(CD_TCP_NAME, tcp_params, tcp_rules)
+TcpModule::TcpModule() : DecodeModule(CD_TCP_NAME)
{ }
-bool TcpModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* TcpModule::get_rules() const
+{ return tcp_rules; }
+
public:
TcpModule();
- bool set(const char*, Value&, SnortConfig*);
-
+ const RuleMap* get_rules() const;
};
#endif
// rpc module
//-------------------------------------------------------------------------
-UdpModule::UdpModule() : DecodeModule(CD_UDP_NAME, udp_params, udp_rules)
+UdpModule::UdpModule() : DecodeModule(CD_UDP_NAME, udp_params)
{ }
+const RuleMap* UdpModule::get_rules() const
+{ return udp_rules; }
+
bool UdpModule::set(const char*, Value& v, SnortConfig* sc)
{
if ( v.is("deep_teredo_inspection") )
public:
UdpModule();
+ const RuleMap* get_rules() const;
bool set(const char*, Value&, SnortConfig*);
-
};
#endif
#include "codecs/link/cd_arp_module.h"
-
-static const Parameter arp_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap arp_rules[] =
{
{ DECODE_ARP_TRUNCATED, "(" CD_ARP_NAME ") Truncated ARP" },
// rpc module
//-------------------------------------------------------------------------
-ArpModule::ArpModule() : DecodeModule(CD_ARP_NAME, arp_params, arp_rules)
+ArpModule::ArpModule() : DecodeModule(CD_ARP_NAME)
{ }
-bool ArpModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* ArpModule::get_rules() const
+{ return arp_rules; }
+
public:
ArpModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/link/cd_eapol_module.h"
-
-static const Parameter eapol_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap eapol_rules[] =
{
{ DECODE_EAPOL_TRUNCATED, "(" CD_EAPOL_NAME ") Truncated EAP Header" },
// rpc module
//-------------------------------------------------------------------------
-EapolModule::EapolModule() : DecodeModule(CD_EAPOL_NAME, eapol_params, eapol_rules)
+EapolModule::EapolModule() : DecodeModule(CD_EAPOL_NAME)
{ }
-bool EapolModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* EapolModule::get_rules() const
+{ return eapol_rules; }
+
public:
EapolModule();
+ const RuleMap* get_rules() const;
bool set(const char*, Value&, SnortConfig*);
};
#include "codecs/link/cd_erspan2_module.h"
-
-static const Parameter erspan2_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap erspan2_rules[] =
{
{ DECODE_ERSPAN_HDR_VERSION_MISMATCH, "(codec_erspan) ERSpan Header version mismatch" },
// rpc module
//-------------------------------------------------------------------------
-Erspan2Module::Erspan2Module() : DecodeModule(CD_ERSPAN2_NAME, erspan2_params, erspan2_rules)
+Erspan2Module::Erspan2Module() : DecodeModule(CD_ERSPAN2_NAME)
{ }
-bool Erspan2Module::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* Erspan2Module::get_rules() const
+{ return erspan2_rules; }
+
public:
Erspan2Module();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/link/cd_erspan3_module.h"
-
-static const Parameter erspan3_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap erspan3_rules[] =
{
{ DECODE_ERSPAN3_DGRAM_LT_HDR, "(" CD_ERSPAN3_NAME ") captured < ERSpan Type3 Header Length" },
// rpc module
//-------------------------------------------------------------------------
-Erspan3Module::Erspan3Module() : DecodeModule(CD_ERSPAN3_NAME, erspan3_params, erspan3_rules)
+Erspan3Module::Erspan3Module() : DecodeModule(CD_ERSPAN3_NAME)
{ }
-bool Erspan3Module::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* Erspan3Module::get_rules() const
+{ return erspan3_rules; }
+
public:
Erspan3Module();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
// mpls module
//-------------------------------------------------------------------------
-MplsModule::MplsModule() : DecodeModule(CD_MPLS_NAME, mpls_params, mpls_rules)
+MplsModule::MplsModule() : DecodeModule(CD_MPLS_NAME, mpls_params)
{ }
+const RuleMap* MplsModule::get_rules() const
+{ return mpls_rules; }
+
bool MplsModule::set(const char*, Value& v, SnortConfig* sc)
{
if ( v.is("enable_mpls_multicast") )
public:
MplsModule();
+ const RuleMap* get_rules() const;
bool set(const char*, Value&, SnortConfig*);
-
};
#endif
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-// cd_pppoepkt_module.cc author Josh Rosenbaum <jrosenba@cisco.com>
+// cd_pppoe_module.cc author Josh Rosenbaum <jrosenba@cisco.com>
#include "codecs/link/cd_pppoe_module.h"
-
-static const Parameter pppoepkt_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
-static const RuleMap pppoepkt_rules[] =
+static const RuleMap pppoe_rules[] =
{
{ DECODE_BAD_PPPOE, "(" CD_PPPOE_NAME ") Bad PPPOE frame detected" },
{ 0, nullptr }
//-------------------------------------------------------------------------
/// ^^^ READ THE COMMENT!
-PPPoEModule::PPPoEModule() : DecodeModule(CD_PPPOE_NAME, pppoepkt_params, pppoepkt_rules)
+PPPoEModule::PPPoEModule() : DecodeModule(CD_PPPOE_NAME)
{ }
-bool PPPoEModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* PPPoEModule::get_rules() const
+{ return pppoe_rules; }
+
public:
PPPoEModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/link/cd_vlan_module.h"
-
-static const Parameter vlan_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap vlan_rules[] =
{
{ DECODE_BAD_VLAN, "(" CD_VLAN_NAME ") Bad VLAN Frame" },
// rpc module
//-------------------------------------------------------------------------
-VlanModule::VlanModule() : DecodeModule(CD_VLAN_NAME, vlan_params, vlan_rules)
+VlanModule::VlanModule() : DecodeModule(CD_VLAN_NAME)
{ }
-bool VlanModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* VlanModule::get_rules() const
+{ return vlan_rules; }
+
public:
VlanModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/misc/cd_gtp_module.h"
-
-static const Parameter gtp_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap gtp_rules[] =
{
// rpc module
//-------------------------------------------------------------------------
-GtpModule::GtpModule() : DecodeModule(CD_GTP_NAME, gtp_params, gtp_rules)
+GtpModule::GtpModule() : DecodeModule(CD_GTP_NAME)
{ }
-bool GtpModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* GtpModule::get_rules() const
+{ return gtp_rules; }
+
public:
GtpModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/root/cd_eth_module.h"
-
-static const Parameter eth_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap eth_rules[] =
{
{ DECODE_ETH_HDR_TRUNC, "(" CD_ETH_NAME ") truncated eth header" },
// rpc module
//-------------------------------------------------------------------------
-EthModule::EthModule() : DecodeModule(CD_ETH_NAME, eth_params, eth_rules)
+EthModule::EthModule() : DecodeModule(CD_ETH_NAME)
{ }
-bool EthModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* EthModule::get_rules() const
+{ return eth_rules; }
+
public:
EthModule();
- bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
};
#endif
#include "codecs/root/cd_wlan_module.h"
-
-static const Parameter wifi_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
-
static const RuleMap wifi_rules[] =
{
{ DECODE_BAD_80211_ETHLLC, "(" CD_WLAN_NAME ") Bad 802.11 LLC header" },
// wifi module
//-------------------------------------------------------------------------
-WlanCodecModule::WlanCodecModule() : DecodeModule(CD_WLAN_NAME, wifi_params, wifi_rules)
+WlanCodecModule::WlanCodecModule() : DecodeModule(CD_WLAN_NAME)
{ }
-bool WlanCodecModule::set(const char*, Value&, SnortConfig*)
-{
- return true;
-}
+const RuleMap* WlanCodecModule::get_rules() const
+{ return wifi_rules; }
+
public:
WlanCodecModule();
+ const RuleMap* get_rules() const;
bool set(const char*, Value&, SnortConfig*);
};
inspector.cc
ips_option.cc
parameter.cc
+ module.cc
mpse.cc
value.cc
)
inspector.cc \
ips_option.cc \
parameter.cc \
+module.cc \
mpse.cc \
value.cc
#include "framework/value.h"
#include "framework/parameter.h"
+#include "framework/counts.h"
struct SnortConfig;
public:
virtual ~Module() { };
+ // configuration:
// for lists (tables with numeric indices):
// int == 0 is list container
// int > 0 is list item
virtual bool end(const char*, int, SnortConfig*)
{ return true; };
- virtual bool set(const char*, Value&, SnortConfig*) = 0;
+ virtual bool set(const char*, Value&, SnortConfig*)
+ { return !get_parameters(); };
+ // ips events:
virtual unsigned get_gid() const
{ return 0; };
- // profile is thread local
- virtual ProfileStats* get_profile() const
- { return nullptr; };
-
- // implement above -or- below
- virtual ProfileStats* get_profile(
- unsigned /*index*/, const char*& /*name*/, const char*& /*parent*/) const
- { return nullptr; };
-
const char* get_name() const
{ return name ? name : params->name; };
const Parameter* get_parameters() const
{ return params; };
- const Command* get_commands() const
- { return cmds; };
+ virtual const Command* get_commands() const
+ { return nullptr; };
- const RuleMap* get_rules() const
- { return rules; };
+ virtual const RuleMap* get_rules() const
+ { return nullptr; };
-protected:
- Module(const char* s, const Parameter* p, bool is_list = false)
- { init(s, p); list = is_list; };
+ virtual const char* get_pegs() const
+ { return nullptr; };
- Module(const char* s, const Parameter* p, const RuleMap* r)
- { init(s, p); rules = r; };
+ // counts and profile are thread local
+ virtual const PegCount* get_counts() const
+ { return nullptr; };
- Module(const char* s, const Parameter* p, const Command* c)
- { init(s, p); cmds = c; };
+ virtual ProfileStats* get_profile() const
+ { return nullptr; };
- Module(const char* s, const Parameter* p, const RuleMap* r, const Command* c)
- { init(s, p); rules = r; cmds = c; };
+ // implement above -or- below
+ virtual ProfileStats* get_profile(
+ unsigned /*index*/, const char*& /*name*/, const char*& /*parent*/) const
+ { return nullptr; };
+
+protected:
+ Module(const char* s);
+ Module(const char* s, const Parameter* p, bool is_list = false);
private:
friend class ModuleManager;
-
- void init(const char* s, const Parameter* p)
- { name = s; params = p; list = false; cmds = nullptr; rules = nullptr; };
+ void init(const char* s);
bool list;
const char* name;
// snort module
//-------------------------------------------------------------------------
-static const Parameter snort_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
static const Command snort_cmds[] =
{
{ "show_plugins", main_dump_plugins, "show available plugins" },
class SnortModule : public Module
{
public:
- SnortModule() : Module("snort", snort_params, snort_cmds) { };
+ SnortModule() : Module("snort") { };
+ const Command* get_commands() const { return snort_cmds; };
bool set(const char*, Value&, SnortConfig*) { return false; };
};
//-------------------------------------------------------------------------
ArpSpoofModule::ArpSpoofModule() :
- Module(mod_name, arp_spoof_params, arp_spoof_rules)
+ Module(mod_name, arp_spoof_params)
{
config = new ArpSpoofConfig;
delete config;
}
+const RuleMap* ArpSpoofModule::get_rules() const
+{ return arp_spoof_rules; }
+
ProfileStats* ArpSpoofModule::get_profile() const
{ return &arpPerfStats; }
unsigned get_gid() const
{ return GID_ARP_SPOOF; };
+ const RuleMap* get_rules() const;
ProfileStats* get_profile() const;
private:
//-------------------------------------------------------------------------
PortScanModule::PortScanModule() :
- Module("port_scan", port_scan_params, port_scan_rules)
+ Module("port_scan", port_scan_params)
{
config = nullptr;
}
delete config;
}
+const RuleMap* PortScanModule::get_rules() const
+{ return port_scan_rules; }
+
//-------------------------------------------------------------------------
// FIXIT ipset_parse() format must be changed to remove comma
// separators between tokens which means using something other than
bool set(const char*, Value&, SnortConfig*);
bool begin(const char*, int, SnortConfig*);
+ const RuleMap* get_rules() const;
+
unsigned get_gid() const
{ return GID_PORT_SCAN; };
#define BO_SNORT_BUFFER_ATTACK_STR \
"(back_orifice) BO Snort buffer attack"
-static const Parameter bo_params[] =
-{
- { nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
-};
-
static const RuleMap bo_rules[] =
{
{ BO_TRAFFIC_DETECT, BO_TRAFFIC_DETECT_STR },
class BoModule : public Module
{
public:
- BoModule() : Module("back_orifice", bo_params, bo_rules)
+ BoModule() : Module("back_orifice")
{ };
- bool set(const char*, Value&, SnortConfig*)
- { return false; };
+ const RuleMap* get_rules() const
+ { return bo_rules; };
unsigned get_gid() const
{ return GID_BO; };
//-------------------------------------------------------------------------
FtpServerModule::FtpServerModule() :
- Module(FTP_SERVER, ftp_server_params, ftp_server_rules)
+ Module(FTP_SERVER, ftp_server_params)
{
conf = nullptr;
}
delete p;
}
+const RuleMap* FtpServerModule::get_rules() const
+{ return ftp_server_rules; }
+
ProfileStats* FtpServerModule::get_profile() const
{ return &ftpPerfStats; }
unsigned get_gid() const
{ return GID_FTP; };
+ const RuleMap* get_rules() const;
ProfileStats* get_profile() const;
FTP_SERVER_PROTO_CONF* get_data();
};
TelnetModule::TelnetModule() :
- Module("telnet", telnet_params, telnet_rules)
+ Module("telnet", telnet_params)
{
conf = nullptr;
}
delete conf;
}
+const RuleMap* TelnetModule::get_rules() const
+{ return telnet_rules; }
+
ProfileStats* TelnetModule::get_profile() const
{ return &telnetPerfStats; }
unsigned get_gid() const
{ return GID_TELNET; };
+ const RuleMap* get_rules() const;
ProfileStats* get_profile() const;
TELNET_PROTO_CONF* get_data();
};
HttpInspectModule::HttpInspectModule() :
- Module(GLOBAL_KEYWORD, hi_global_params, hi_global_rules)
+ Module(GLOBAL_KEYWORD, hi_global_params)
{
config = nullptr;
}
delete config;
}
+const RuleMap* HttpInspectModule::get_rules() const
+{ return hi_global_rules; }
+
ProfileStats* HttpInspectModule::get_profile() const
{ return &hiPerfStats; }
};
HttpServerModule::HttpServerModule() :
- Module(SERVER_KEYWORD, hi_server_params, hi_server_rules)
+ Module(SERVER_KEYWORD, hi_server_params)
{
server = nullptr;
}
delete server;
}
+const RuleMap* HttpServerModule::get_rules() const
+{ return hi_server_rules; }
+
HTTPINSPECT_CONF* HttpServerModule::get_data()
{
HTTPINSPECT_CONF* tmp = server;
unsigned get_gid() const
{ return GID_HTTP_CLIENT; };
+ const RuleMap* get_rules() const;
ProfileStats* get_profile() const;
HTTPINSPECT_GLOBAL_CONF* get_data();
bool begin(const char*, int, SnortConfig*);
bool end(const char*, int, SnortConfig*);
+ const RuleMap* get_rules() const;
+
unsigned get_gid() const
{ return GID_HTTP_SERVER; };
#include "nhttp_enum.h"
#include "nhttp_module.h"
-NHttpModule::NHttpModule() : Module("nhttp_inspect", nhttpParams, nhttpEvents) {
-}
+NHttpModule::NHttpModule() : Module("nhttp_inspect", nhttpParams)
+{ }
+
+const RuleMap* NHttpModule::get_rules() const
+{ return nhttpEvents; }
const Parameter NHttpModule::nhttpParams[] =
{{ "test_input", Parameter::PT_BOOL, nullptr, "false", "read HTTP messages from text file" },
bool end(const char*, int, SnortConfig*);
bool set(const char*, Value&, SnortConfig*);
unsigned get_gid() const;
+ const RuleMap* get_rules() const;
bool get_test_input() const { return test_input; };
bool get_test_output() const { return test_output; };
// rpc module
//-------------------------------------------------------------------------
-RpcModule::RpcModule() : Module("rpc_decode", rpc_params, rpc_rules)
+RpcModule::RpcModule() : Module("rpc_decode", rpc_params)
{ }
+const RuleMap* RpcModule::get_rules() const
+{ return rpc_rules; }
+
ProfileStats* RpcModule::get_profile() const
{ return &rpcdecodePerfStats; }
unsigned get_gid() const
{ return GID_RPC_DECODE; };
+ const RuleMap* get_rules() const;
ProfileStats* get_profile() const;
};
{ nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
};
-static const RuleMap stream_rules[] =
-{
- { 0, nullptr }
-};
-
StreamModule::StreamModule() :
- Module(MOD_NAME, stream_params, stream_rules)
+ Module(MOD_NAME, stream_params)
{
proto = &stream_cfg.ip_cfg;
}
{ nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
};
-static const RuleMap stream_icmp_rules[] =
-{
- { 0, nullptr }
-};
-
StreamIcmpModule::StreamIcmpModule() :
- Module(MOD_NAME, stream_icmp_params, stream_icmp_rules)
+ Module(MOD_NAME, stream_icmp_params)
{
config = nullptr;
}
};
StreamIpModule::StreamIpModule() :
- Module(MOD_NAME, stream_ip_params, stream_ip_rules)
+ Module(MOD_NAME, stream_ip_params)
{
config = nullptr;
}
delete config;
}
+const RuleMap* StreamIpModule::get_rules() const
+{ return stream_ip_rules; }
+
ProfileStats* StreamIpModule::get_profile(
unsigned index, const char*& name, const char*& parent) const
{
bool begin(const char*, int, SnortConfig*);
bool end(const char*, int, SnortConfig*);
+ const RuleMap* get_rules() const;
ProfileStats* get_profile(unsigned, const char*&, const char*&) const;
StreamIpConfig* get_data();
};
StreamTcpModule::StreamTcpModule() :
- Module(MOD_NAME, stream_tcp_params, stream_tcp_rules)
+ Module(MOD_NAME, stream_tcp_params)
{
config = nullptr;
}
delete p;
}
+const RuleMap* StreamTcpModule::get_rules() const
+{ return stream_tcp_rules; }
+
ProfileStats* StreamTcpModule::get_profile(
unsigned index, const char*& name, const char*& parent) const
{
bool begin(const char*, int, SnortConfig*);
bool end(const char*, int, SnortConfig*);
+ const RuleMap* get_rules() const;
+
unsigned get_gid() const
{ return GID_STREAM_TCP; };
{ nullptr, Parameter::PT_MAX, nullptr, nullptr, nullptr }
};
-static const RuleMap stream_udp_rules[] =
-{
- { 0, nullptr }
-};
-
StreamUdpModule::StreamUdpModule() :
- Module(MOD_NAME, stream_udp_params, stream_udp_rules)
+ Module(MOD_NAME, stream_udp_params)
{
config = nullptr;
}
// ppm module
//-------------------------------------------------------------------------
-PpmModule::PpmModule() : Module("ppm", ppm_params, ppm_rules) { }
+PpmModule::PpmModule() : Module("ppm", ppm_params) { }
+
+const RuleMap* PpmModule::get_rules() const
+{ return ppm_rules; }
bool PpmModule::set(const char*, Value& v, SnortConfig* sc)
{
PpmModule();
bool set(const char*, Value&, SnortConfig*);
+ const RuleMap* get_rules() const;
+
unsigned get_gid() const
{ return GID_PPM; };
};
#include "sfip/sf_ipvar.h"
#include "sfip/ipv6_port.h"
#include "utils/sflsq.h"
-
-typedef uint64_t PegCount;
+#include "framework/counts.h"
struct PacketCount
{
PegCount attribute_table_hosts;
};
-struct SimpleStats
-{
- PegCount total_packets;
-};
-
extern ProcessCount proc_stats;
extern THREAD_LOCAL PacketCount pc;
-#define array_size(a) (sizeof(a)/sizeof(a[0]))
-
void sum_stats(PegCount* sums, PegCount* counts, unsigned n);
void show_stats(PegCount*, const char* names[], unsigned n,
const char* module_name = nullptr);
projects / thirdparty / snort3.git / commitdiff
