{ return DETECT; }
public:
- ASN1_CTXT data;
+ ASN1_CTXT data = {};
};
bool Asn1Module::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- Base64DecodeData data;
+ Base64DecodeData data = {};
};
bool B64DecodeModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- uint32_t type;
+ uint32_t type = 0;
};
bool BerDataModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- uint32_t type;
- bool optional;
+ uint32_t type = 0;
+ bool optional = false;
};
bool BerSkipModule::begin(const char*, int, SnortConfig*)
class ExtractModule : public Module
{
public:
- ExtractModule() : Module(s_name, s_help, s_params) { }
+ ExtractModule() : Module(s_name, s_help, s_params) { data.multiplier = 1; }
bool begin(const char*, int, SnortConfig*) override;
bool end(const char*, int, SnortConfig*) override;
{ return DETECT; }
public:
- ByteExtractData data;
+ ByteExtractData data = {};
};
bool ExtractModule::begin(const char*, int, SnortConfig*)
class ByteJumpModule : public Module
{
public:
- ByteJumpModule() : Module(s_name, s_help, s_params) { }
+ ByteJumpModule() : Module(s_name, s_help, s_params) { data.multiplier = 1; }
bool begin(const char*, int, SnortConfig*) override;
bool end(const char*, int, SnortConfig*) override;
{ return DETECT; }
public:
- ByteJumpData data;
+ ByteJumpData data = {};
string var;
string post_var;
};
{ return DETECT; }
public:
- ByteMathData data;
+ ByteMathData data = {};
string rvalue_var;
string off_var;
};
{ return DETECT; }
public:
- ByteTestData data;
+ ByteTestData data = {};
string cmp_var;
string off_var;
};
{ return DETECT; }
public:
- const ClassType* type;
+ const ClassType* type = nullptr;
};
bool ClassTypeModule::set(const char*, Value& v, SnortConfig* sc)
{ return DETECT; }
public:
- CvsRuleOption data;
+ CvsRuleOption data = {};
};
bool CvsModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- THDX_STRUCT thdx;
- DetectionFilterConfig* dfc;
+ THDX_STRUCT thdx = {};
+ DetectionFilterConfig* dfc = nullptr;
};
bool DetectionFilterModule::begin(const char*, int, SnortConfig* sc)
{ return DETECT; }
public:
- IpsPolicy::Enable enable;
+ IpsPolicy::Enable enable = IpsPolicy::Enable::ENABLED;
};
bool EnableModule::begin(const char*, int, SnortConfig* sc)
{ return DETECT; }
public:
- TcpFlagCheckData data;
+ TcpFlagCheckData data = {};
};
bool FlagsModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- FlowCheckData data;
+ FlowCheckData data = {};
};
bool FlowModule::begin(const char*, int, SnortConfig*)
FlowBitCheck* get_data();
public:
- FlowBitCheck::Op op;
+ FlowBitCheck::Op op = FlowBitCheck::Op::SET;
std::string bits;
FlowBitCheck* fbc = nullptr;
};
{ return DETECT; }
public:
- uint32_t gid;
+ uint32_t gid = 0;
};
bool GidModule::set(const char*, Value& v, SnortConfig*)
static void parse_hash(HashMatchData* hmd, const char* rule)
{
- parse_byte_code(rule, hmd->negated, hmd->hash);
+ if (!parse_byte_code(rule, hmd->negated, hmd->hash))
+ ParseError("Invalid hash");
}
// FIXIT-L refactor for general use?
{ return DETECT; }
public:
- IpProtoData data;
+ IpProtoData data = {};
};
bool IpProtoModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- IpOptionData data;
+ IpOptionData data = {};
};
bool IpOptModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- IsDataAtData data;
+ IsDataAtData data = {};
};
bool IsDataAtModule::begin(const char*, int, SnortConfig*)
Usage get_usage() const override
{ return DETECT; }
- bool match;
+ bool match = false;
};
bool MetadataModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- int priority;
+ int priority = 0;
};
bool PriorityModule::set(const char*, Value& v, SnortConfig*)
public:
std::string scheme;
std::string id;
- SnortConfig* snort_config;
+ SnortConfig* snort_config = nullptr;
};
bool ReferenceModule::begin(const char*, int, SnortConfig* sc)
bool RegexModule::convert_pcre_to_regex_form()
{
size_t pos = config.re.find_first_of("\"!");
- if (config.re[pos] == '!')
+ if (pos != std::string::npos and config.re[pos] == '!')
return false;
config.re.erase(0,2);
{ return DETECT; }
public:
- uint32_t rev;
+ uint32_t rev = 0;
};
bool RevModule::set(const char*, Value& v, SnortConfig*)
{ return DETECT; }
public:
- RpcCheckData data;
+ RpcCheckData data = {};
};
bool RpcModule::begin(const char*, int, SnortConfig*)
{ return DETECT; }
public:
- uint32_t sid;
+ uint32_t sid = 0;
};
bool SidModule::set(const char*, Value& v, SnortConfig*)
public:
string name;
- bool relative_flag;
- SnortConfig* cfg;
+ bool relative_flag = false;
+ SnortConfig* cfg = nullptr;
};
bool SoModule::begin(const char*, int, SnortConfig* sc)
{ return DETECT; }
public:
- Target target;
+ Target target = Target::TARGET_NONE;
};
bool TargetModule::set(const char*, Value& v, SnortConfig*)
static void ff_flowstart_time(const Args& a)
{
if (a.pkt->flow)
- TextLog_Print(csv_log, "%u", a.pkt->flow->flowstats.start_time.tv_sec);
+ TextLog_Print(csv_log, "%lu", a.pkt->flow->flowstats.start_time.tv_sec);
}
static void ff_gid(const Args& a)
static void ff_seconds(const Args& a)
{
- TextLog_Print(csv_log, "%u", a.pkt->pkth->ts.tv_sec);
+ TextLog_Print(csv_log, "%lu", a.pkt->pkth->ts.tv_sec);
}
static void ff_server_bytes(const Args& a)
{ return GLOBAL; }
public:
- bool file;
- size_t limit;
+ bool file = false;
+ size_t limit = 0;
string sep;
vector<CsvFunc> fields;
};
fields.clear();
while ( v.get_next_token(tok) )
- fields.emplace_back(csv_func[Parameter::index(csv_range, tok.c_str())]);
+ {
+ int i = Parameter::index(csv_range, tok.c_str());
+ if ( i >= 0 )
+ fields.emplace_back(csv_func[i]);
+ }
}
else if ( v.is("limit") )
v.set_first_token();
while ( v.get_next_token(tok) )
- fields.emplace_back(csv_func[Parameter::index(csv_range, tok.c_str())]);
+ {
+ int i = Parameter::index(csv_range, tok.c_str());
+ if ( i >= 0 )
+ fields.emplace_back(csv_func[i]);
+ }
}
return true;
}
{ return GLOBAL; }
public:
- size_t limit;
- bool file;
- bool packet;
+ size_t limit = 0;
+ bool file = false;
+ bool packet = false;
};
bool FastModule::set(const char*, Value& v, SnortConfig*)
{ return GLOBAL; }
public:
- bool file;
- size_t limit;
+ bool file = false;
+ size_t limit = 0;
};
bool FullModule::set(const char*, Value& v, SnortConfig*)
if (a.pkt->flow)
{
print_label(a, "flowstart_time");
- TextLog_Print(json_log, "%u", a.pkt->flow->flowstats.start_time.tv_sec);
+ TextLog_Print(json_log, "%lu", a.pkt->flow->flowstats.start_time.tv_sec);
return true;
}
return false;
static bool ff_seconds(const Args& a)
{
print_label(a, "seconds");
- TextLog_Print(json_log, "%u", a.pkt->pkth->ts.tv_sec);
+ TextLog_Print(json_log, "%lu", a.pkt->pkth->ts.tv_sec);
return true;
}
{ return GLOBAL; }
public:
- bool file;
- size_t limit;
+ bool file = false;
+ size_t limit = 0;
string sep;
vector<JsonFunc> fields;
};
fields.clear();
while ( v.get_next_token(tok) )
- fields.emplace_back(json_func[Parameter::index(json_range, tok.c_str())]);
+ {
+ int i = Parameter::index(json_range, tok.c_str());
+ if ( i >= 0 )
+ fields.emplace_back(json_func[i]);
+ }
}
else if ( v.is("limit") )
v.set_first_token();
while ( v.get_next_token(tok) )
- fields.emplace_back(json_func[Parameter::index(json_range, tok.c_str())]);
+ {
+ int i = Parameter::index(json_range, tok.c_str());
+ if ( i >= 0 )
+ fields.emplace_back(json_func[i]);
+ }
}
return true;
}
#include "protocols/packet.h"
#include "target_based/snort_protocols.h"
#include "utils/util.h"
+#include "utils/util_cstring.h"
using namespace snort;
using namespace std;
public:
string file;
RuleVector rulez;
- RuleId rule;
+ RuleId rule = {};
};
bool SfSocketModule::set(const char*, Value& v, SnortConfig*)
memset(&context.addr, 0, sizeof(context.addr));
context.addr.sun_family = AF_UNIX;
- memcpy(context.addr.sun_path + 1, name.c_str(), strlen(name.c_str()));
+ SnortStrncpy(context.addr.sun_path, name.c_str(), sizeof(context.addr.sun_path));
if (AlertSFSocket_Connect() == 0)
context.connected = 1;
{ return GLOBAL; }
public:
- int facility;
- int level;
- int options;
+ int facility = 0;
+ int level = 0;
+ int options = 0;
};
bool SyslogModule::set(const char*, Value& v, SnortConfig*)
#include "log/messages.h"
#include "protocols/packet.h"
#include "utils/util.h"
+#include "utils/util_cstring.h"
using namespace snort;
us.addr.sun_family = AF_UNIX;
/* copy path over and preserve a null byte at the end */
- strncpy(us.addr.sun_path, name.c_str(), sizeof(us.addr.sun_path)-1);
+ SnortStrncpy(us.addr.sun_path, name.c_str(), sizeof(us.addr.sun_path));
if ( (us.socket = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0 )
FatalError("socket() call failed: %s", get_error(errno));
{ return GLOBAL; }
public:
- bool print_to_file;
- uint8_t flags;
+ bool print_to_file = false;
+ uint8_t flags = 0;
};
} // namespace
int vlan_tag = fs->vlan_tag == 0xfff ? 0 : fs->vlan_tag;
TextLog_Print(hext_log,
- "\n$%s %d %d %d %d %s %d %s %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
+ "\n$%s %d %d %d %d %s %d %s %d %u %lu %lu %lu %lu %lu %lu %d %lu %lu %d %d %d\n",
cmd,
fs->ingressZone,
fs->egressZone,
{ return GLOBAL; }
public:
- bool file;
- bool raw;
- size_t limit;
- unsigned width;
+ bool file = false;
+ bool raw = false;
+ size_t limit = 0;
+ unsigned width = 20;
};
bool HextModule::set(const char*, Value& v, SnortConfig*)
{ return GLOBAL; }
public:
- size_t limit;
+ size_t limit = 0;
};
bool TcpdumpModule::set(const char*, Value& v, SnortConfig*)
unsigned u2_type, U2PseudoHeader* u2h = nullptr)
{
Serial_Unified2_Header hdr;
- Serial_Unified2Packet logheader;
+ Serial_Unified2Packet logheader = {};
uint32_t pkt_length = 0;
uint32_t write_len = sizeof(hdr) + sizeof(Serial_Unified2Packet) - 4;
{ return GLOBAL; }
public:
- size_t limit;
- bool nostamp;
- bool legacy_events;
+ size_t limit = 0;
+ bool nostamp = true;
+ bool legacy_events = false;
};
bool U2Module::set(const char*, Value& v, SnortConfig*)
#include "control.h"
#include "request.h"
#include "snort_config.h"
+#include "utils/util_cstring.h"
using namespace snort;
using namespace std;
memset(&unix_addr, 0, sizeof(unix_addr));
unix_addr.sun_family = AF_UNIX;
- strncpy(unix_addr.sun_path, fullpath.c_str(), sizeof(unix_addr.sun_path)-1);
+ SnortStrncpy(unix_addr.sun_path, fullpath.c_str(), sizeof(unix_addr.sun_path));
sock_addr = (struct sockaddr*)&unix_addr;
sock_addr_size = sizeof(unix_addr);
unlink(fullpath.c_str());
const unsigned hex_per_row = 16;
+ std::ios_base::fmtflags f(cout.flags());
cout << "static const uint8_t rule_" << var;
cout << "[] =" << endl;
cout << "{" << endl << " ";
cout << "};" << endl;
cout << "static const unsigned rule_" << var << "_len = ";
cout << data.size() << ";" << endl;
+ cout.flags(f);
}
void SoManager::rule_to_text(const char* delim)
private:
//19 bits for microseconds
//45 bits for seconds (out to year 1116918)
- uint64_t last_wt;
- uint64_t last_ut;
- uint64_t last_st;
+ uint64_t last_wt = 0;
+ uint64_t last_ut = 0;
+ uint64_t last_st = 0;
PegCount user_stat;
PegCount system_stat;
formatter->register_field("udp_created", (PegCount*)
&stats.state_changes[SFS_STATE_UDP_CREATED]);
formatter->finalize_fields();
+ stats.total_packets = stats.total_bytes = 0;
memcap = perf->flowip_memcap;
ip_map = new XHash(DEFAULT_XHASH_NROWS, sizeof(FlowStateKey), sizeof(FlowStateValue), memcap);
virtual void write();
uint64_t max_file_size = 0;
- PerfFormatter* formatter;
+ PerfFormatter* formatter = nullptr;
private:
std::string fname;
std::string tracker_name;
FILE* fh = nullptr;
- time_t cur_time;
+ time_t cur_time = 0;
};
#endif
projects / thirdparty / snort3.git / commitdiff
