extern const ConvertMap *autogenerate_decode_rules_map;
+extern const ConvertMap *checksum_map;
extern const ConvertMap *paf_max_map;
const std::vector<const ConvertMap*> config_api =
{
autogenerate_decode_rules_map,
+ checksum_map,
paf_max_map,
};
bool PafMax::convert(std::stringstream& data_stream)
{
- converter->open_table("stream_tcp");
+ cv->open_table("stream_tcp");
bool retval = parse_int_option("paf_max", data_stream);
- converter->close_table();
- return retval;
+ cv->close_table();
+ return retval;
}
/******* A P I ***********/
};
const ConvertMap* autogenerate_decode_rules_map = &config_autogenerate_decode_rules;
+
+
+
+/*********************************************
+ ************* Checksum ********************
+ *********************************************/
+
+namespace {
+
+class Checksum : public ConversionState
+{
+public:
+ Checksum(Converter* cv) : ConversionState(cv) {};
+ virtual ~Checksum() {};
+ virtual bool convert(std::stringstream& data_stream);
+};
+
+} // namespace
+
+
+bool Checksum::convert(std::stringstream& data_stream)
+{
+ cv->open_table("nework");
+ bool retval = parse_string_option("checksum_eval", data_stream);
+ cv->close_table();
+ return retval;
+}
+
+/******* A P I ***********/
+
+static ConversionState* checksum_ctor(Converter* cv)
+{
+ return new Checksum(cv);
+}
+
+static const ConvertMap config_checksum =
+{
+ "checksum_mode",
+ checksum_ctor,
+};
+
+
+const ConvertMap* checksum_map = &config_checksum;
{
public:
- ConversionState(Converter *cv){ converter = cv; }
+ ConversionState(Converter *cv){ this->cv = cv; }
virtual ~ConversionState() {};
virtual bool convert(std::stringstream& data)=0;
protected:
- Converter* converter;
+ Converter* cv;
inline bool parse_string_option(std::string opt_name, std::stringstream& stream)
{
if(val.back() == ',')
val.pop_back();
- converter->add_option_to_table(opt_name, val);
+ cv->add_option_to_table(opt_name, val);
return true;
}
- converter->add_comment_to_table("snort.conf missing argument for: " + opt_name + " <int>");
+ cv->add_comment_to_table("snort.conf missing argument for: " + opt_name + " <int>");
return false;
}
if(stream >> val)
{
- converter->add_option_to_table(opt_name, val);
+ cv->add_option_to_table(opt_name, val);
return true;
}
- converter->add_comment_to_table("snort.conf missing argument for: " + opt_name + " <int>");
+ cv->add_comment_to_table("snort.conf missing argument for: " + opt_name + " <int>");
return false;
}
return false;
while (stream >> elem && elem != "}")
- retval = converter->add_list_to_table(list_name, elem) && retval;
+ retval = cv->add_list_to_table(list_name, elem) && retval;
return retval;
}
return false;
else if(!val.compare("yes"))
- return converter->add_option_to_table(opt_name, true);
+ return cv->add_option_to_table(opt_name, true);
else if (!val.compare("no"))
- return converter->add_option_to_table(opt_name, false);
+ return cv->add_option_to_table(opt_name, false);
- converter->add_comment_to_table("Unable to convert_option: " + opt_name + ' ' + val);
+ cv->add_comment_to_table("Unable to convert_option: " + opt_name + ' ' + val);
return false;
}
{
std::stringstream tmp;
tmp << "0x" << std::hex << dig;
- retval = converter->add_list_to_table(list_name, tmp.str()) && retval;
+ retval = cv->add_list_to_table(list_name, tmp.str()) && retval;
}
else
{
- converter->add_comment_to_table("Unable to convert " + elem +
+ cv->add_comment_to_table("Unable to convert " + elem +
"!! The element must be a single charachter or number between 0 - 255 inclusive");
retval = false;
}
if(tmp.size() > 0)
tmp.erase(tmp.begin());
- return converter->add_option_to_table("--" + list_name, tmp );
+ return cv->add_option_to_table("--" + list_name, tmp );
}
inline bool open_table_add_option(std::string table_name, std::string opt_name, std::string val)
{
- bool tmpval = converter->open_table(table_name);
- tmpval = converter->add_option_to_table(opt_name, val) && tmpval;
- converter->close_table();
+ bool tmpval = cv->open_table(table_name);
+ tmpval = cv->add_option_to_table(opt_name, val) && tmpval;
+ cv->close_table();
return tmpval;
}
}
-void Table::add_comment(std::string comment)
+void Table::add_comment(std::string c)
{
- if (comment.size() > 80)
- comment.insert(76, "...");
+ if (c.size() > 80)
+ c.insert(76, "...");
- comments.push_back(std::string(comment, 0, 77));
+ if (std::find(comments.begin(), comments.end(), c) == comments.end())
+ comments.push_back(std::string(c, 0, 79));
}
std::ostream &operator<<( std::ostream& out, const Table &t)
{
std::string keyword;
+ if (!(data_stream >> keyword))
+ return false;
- if ( data_stream >> keyword )
+ const ConvertMap *map = util::find_map(keyword_api, keyword);
+ if (map)
{
-
- if( keyword.front() == '#')
- {
- std::cout << "THIS SHOULD NEVER OCCUR" << std::endl;
- keyword.erase(keyword.begin());
- converter->add_comment_to_file(keyword, data_stream);
- data_stream.setstate(std::basic_ios<char>::eofbit);
- return true;
- }
- else
- {
- const ConvertMap *map = util::find_map(keyword_api, keyword);
-
- if (map)
- {
- converter->set_state(map->ctor(converter));
- return true;
- }
- }
+ cv->set_state(map->ctor(cv));
+ return true;
}
-// out << "--" << data_stream.str() << std::endl;
-// data_stream.setstate(std::basic_ios<char>::eofbit);
return false;
}
const ConvertMap* map = util::find_map(config_api, keyword);
if (map)
{
- converter->set_state(map->ctor(converter));
+ cv->set_state(map->ctor(cv));
return true;
}
}
const ConvertMap* map = util::find_map(output_api, keyword);
if (map)
{
- converter->set_state(map->ctor(converter));
+ cv->set_state(map->ctor(cv));
return true;
}
}
const ConvertMap* map = util::find_map(output_api, keyword);
if (map)
{
- converter->set_state(map->ctor(converter));
+ cv->set_state(map->ctor(cv));
return true;
}
}
const ConvertMap* map = util::find_map(preprocessor_api, keyword);
if (map)
{
- converter->set_state(map->ctor(converter));
+ cv->set_state(map->ctor(cv));
return true;
}
}
bool retval = true;
std::string keyword;
- converter->open_table("suppress");
- converter->add_deprecated_comment("gen_id", "gid");
- converter->add_deprecated_comment("sig_id", "sid");
- converter->open_table();
+ cv->open_table("suppress");
+ cv->add_deprecated_comment("gen_id", "gid");
+ cv->add_deprecated_comment("sig_id", "sid");
+ cv->open_table();
while(data_stream >> keyword)
{
bool Var::convert(std::stringstream& data_stream)
{
- std::string ports;// converter->print_line(data_stream);
+ std::string ports;// cv->print_line(data_stream);
if (first_line)
if (!(data_stream >> keyword))
util::split(ports, ',', port_list);
for(std::string elem : port_list)
- retval = converter->add_variable(keyword, elem) && retval;
+ retval = cv->add_variable(keyword, elem) && retval;
return retval;
}
else
{
- return converter->add_variable(keyword, ports);
+ return cv->add_variable(keyword, ports);
}
}
{
std::string keyword;
bool retval = true;
- converter->open_table("arp_spoof");
+ cv->open_table("arp_spoof");
while(data_stream >> keyword)
{
if(!keyword.compare("-unicast"))
- retval = converter->add_option_to_table("unicast", true) && retval;
+ retval = cv->add_option_to_table("unicast", true) && retval;
else
retval = false;
std::string ip, mac;
bool retval = true;
- converter->open_table("arp_spoof");
- converter->open_table("hosts");
+ cv->open_table("arp_spoof");
+ cv->open_table("hosts");
while(data_stream >> ip &&
data_stream >> mac)
{
- converter->open_table();
- converter->add_option_to_table("ip", ip);
- converter->add_option_to_table("mac", mac);
- converter->close_table();
+ cv->open_table();
+ cv->add_option_to_table("ip", ip);
+ cv->add_option_to_table("mac", mac);
+ cv->close_table();
ip.clear();
mac.clear();
{
bool retval;
- converter->open_table("telnet");
- retval = converter->add_option_to_table(opt_name, val);
- converter->close_table();
- converter->open_table("ftp_server");
- retval = converter->add_option_to_table(opt_name, val) && retval;
- converter->close_table();
+ cv->open_table("telnet");
+ retval = cv->add_option_to_table(opt_name, val);
+ cv->close_table();
+ cv->open_table("ftp_server");
+ retval = cv->add_option_to_table(opt_name, val) && retval;
+ cv->close_table();
return retval;
}
void FtpTelnet::add_ftp_n_telnet_deprecated(std::string opt_name)
{
- converter->open_table("telnet");
- converter->add_deprecated_comment(opt_name);
- converter->close_table();
- converter->open_table("ftp_server");
- converter->add_deprecated_comment(opt_name);
- converter->close_table();
+ cv->open_table("telnet");
+ cv->add_deprecated_comment(opt_name);
+ cv->close_table();
+ cv->open_table("ftp_server");
+ cv->add_deprecated_comment(opt_name);
+ cv->close_table();
}
bool FtpTelnet::convert(std::stringstream& data_stream)
{
if(keyword.compare("global"))
{
- converter->log_error("preprocessor ftp_telnet: requires the 'global' keyword");
+ cv->log_error("preprocessor ftp_telnet: requires the 'global' keyword");
return false;
}
}
if(!(data_stream >> i_val))
return false;
- converter->open_table("alt_max_param");
- converter->open_table();
- converter->add_option_to_table("length", i_val);
+ cv->open_table("alt_max_param");
+ cv->open_table();
+ cv->add_option_to_table("length", i_val);
tmpval = parse_curly_bracket_list("commands", data_stream);
- converter->close_table();
- converter->close_table();
+ cv->close_table();
+ cv->close_table();
return tmpval;
}
return false;
- converter->open_table("cmd_validity");
- converter->open_table();
- tmpval = converter->add_option_to_table("command", val);
- tmpval = converter->add_list_to_table("format", elem) && tmpval;
+ cv->open_table("cmd_validity");
+ cv->open_table();
+ tmpval = cv->add_option_to_table("command", val);
+ tmpval = cv->add_list_to_table("format", elem) && tmpval;
while((data_stream >> elem) && (elem != ">"))
- tmpval = converter->add_list_to_table("format", elem) && tmpval;
+ tmpval = cv->add_list_to_table("format", elem) && tmpval;
- converter->add_list_to_table("format", elem);
- converter->close_table(); // anonymouse table
- converter->close_table(); // "cmd_validity" table
+ cv->add_list_to_table("format", elem);
+ cv->close_table(); // anonymouse table
+ cv->close_table(); // "cmd_validity" table
return tmpval;
}
if (data_stream >> keyword)
{
if(!keyword.compare("default"))
- converter->open_table("ftp_server");
+ cv->open_table("ftp_server");
else
{
- converter->open_table("ftp_server_target_" + std::to_string(ftpsever_binding_id));
+ cv->open_table("ftp_server_target_" + std::to_string(ftpsever_binding_id));
ftpsever_binding_id++;
- converter->add_comment_to_table("Unable to create target based ftp configuration at this time!!!");
+ cv->add_comment_to_table("Unable to create target based ftp configuration at this time!!!");
retval = false;
}
}
if(!keyword.compare("print_cmds"))
- converter->add_option_to_table("print_cmds", true);
+ cv->add_option_to_table("print_cmds", true);
else if(!keyword.compare("def_max_param_len"))
tmpval = parse_int_option("def_max_param_len", data_stream);
else if(!keyword.compare("data_chan"))
{
- converter->add_deprecated_comment("data_chan", "ignore_data_chan");
- tmpval = converter->add_option_to_table("ignore_data_chan", true);
+ cv->add_deprecated_comment("data_chan", "ignore_data_chan");
+ tmpval = cv->add_option_to_table("ignore_data_chan", true);
}
else if (!keyword.compare("ports"))
{
- converter->add_deprecated_comment("ports", "bindings");
- converter->add_comment_to_table("check bindings table for port information");
+ cv->add_deprecated_comment("ports", "bindings");
+ cv->add_comment_to_table("check bindings table for port information");
// add commented list for now
std::string tmp = "";
while (data_stream >> keyword && keyword != "}")
tmp += " " + keyword;
- tmpval = converter->add_option_to_table("--ports", tmp + "}");
+ tmpval = cv->add_option_to_table("--ports", tmp + "}");
}
else
if (data_stream >> keyword)
{
if(!keyword.compare("default"))
- converter->open_table("ftp_client");
+ cv->open_table("ftp_client");
else
{
- converter->open_table("ftp_client_target_" + std::to_string(ftpclient_binding_id));
+ cv->open_table("ftp_client_target_" + std::to_string(ftpclient_binding_id));
ftpclient_binding_id++;
- converter->add_comment_to_table("Unable to create target based ftp configuration at this time!!!");
+ cv->add_comment_to_table("Unable to create target based ftp configuration at this time!!!");
retval = false;
}
}
std::string tmp = "";
while (data_stream >> keyword && keyword != "}")
tmp += " " + keyword;
- tmpval = converter->add_option_to_table("--bounce_to", tmp + "}");
+ tmpval = cv->add_option_to_table("--bounce_to", tmp + "}");
}
else
int i_val;
bool retval = true;
- converter->open_table("telnet");
+ cv->open_table("telnet");
while(data_stream >> keyword)
{
if(!keyword.compare("ayt_attack_thresh"))
{
if(data_stream >> i_val)
- tmpval = converter->add_option_to_table("ayt_attack_thresh", i_val);
+ tmpval = cv->add_option_to_table("ayt_attack_thresh", i_val);
else
tmpval = false;
}
else if(!keyword.compare("normalize"))
- tmpval = converter->add_option_to_table("normalize", true);
+ tmpval = cv->add_option_to_table("normalize", true);
else if(!keyword.compare("ports"))
{
- converter->add_deprecated_comment("ports", "bindings");
- converter->add_comment_to_table("check bindings table for port information");
+ cv->add_deprecated_comment("ports", "bindings");
+ cv->add_comment_to_table("check bindings table for port information");
// vvvv defined in ConversionState vvvv
parse_curly_bracket_list("--ports", data_stream); // create a commented list of the ports
}
else if(!keyword.compare("detect_anomalies"))
- tmpval = converter->add_option_to_table("detect_anomalies", true);
+ tmpval = cv->add_option_to_table("detect_anomalies", true);
else
tmpval = false;
retval = tmpval && retval;
}
-
- converter->close_table(); // not necessary but
return retval;
}
{
if(!protocol.compare("telnet"))
{
- converter->set_state(new Telnet(converter));
+ cv->set_state(new Telnet(cv));
}
else if (!protocol.compare("ftp"))
{
if(data_stream >> protocol)
{
if(!protocol.compare("client"))
- converter->set_state(new FtpClient(converter));
+ cv->set_state(new FtpClient(cv));
else if (!protocol.compare("server"))
- converter->set_state(new FtpServer(converter));
+ cv->set_state(new FtpServer(cv));
else
return false;
{
if(keyword.compare("global"))
{
- converter->log_error("preprocessor httpinspect: requires the 'global' keyword");
+ cv->log_error("preprocessor httpinspect: requires the 'global' keyword");
return false;
}
}
- converter->open_table("http_inspect");
+ cv->open_table("http_inspect");
retval = parse_int_option("decompress_depth", data_stream) && retval;
else if(!keyword.compare("detect_anomalous_servers"))
- converter->add_option_to_table("detect_anomalous_servers", true);
+ cv->add_option_to_table("detect_anomalous_servers", true);
else if(!keyword.compare("proxy_alert"))
- converter->add_option_to_table("proxy_alert", true);
+ cv->add_option_to_table("proxy_alert", true);
else if(!keyword.compare("max_gzip_mem"))
retval = parse_int_option("max_gzip_mem", data_stream) && retval;
retval = parse_int_option("memcap", data_stream) && retval;
else if(!keyword.compare("disabled"))
- converter->add_deprecated_comment("disabled");
+ cv->add_deprecated_comment("disabled");
else if(!keyword.compare("b64_decode_depth"))
retval = add_decode_option("b64_decode_depth", data_stream) && retval;
if( (data_stream >> codemap) &&
(data_stream >> code_page))
{
- converter->open_table("unicode_map");
- converter->add_option_to_table("map_file", codemap);
- converter->add_option_to_table("code_page", code_page);
- converter->close_table();
+ cv->open_table("unicode_map");
+ cv->add_option_to_table("map_file", codemap);
+ cv->add_option_to_table("code_page", code_page);
+ cv->close_table();
}
else
{
- converter->add_comment_to_table("snort.conf missing argument for "
+ cv->add_comment_to_table("snort.conf missing argument for "
"iis_unicode_map <filename> <codemap>");
retval = false;
}
else
{
- converter->log_error("'preprocessor http_inspect: global' --> Invalid argument!!");
+ cv->log_error("'preprocessor http_inspect: global' --> Invalid argument!!");
retval = false;
}
}
if (stream >> val)
{
- converter->open_table("decode");
- converter->add_option_to_table(opt_name, val);
- converter->close_table();
+ cv->open_table("decode");
+ cv->add_option_to_table(opt_name, val);
+ cv->close_table();
return true;
}
else
{
- converter->add_comment_to_table("snort.conf missing argument for " +
+ cv->add_comment_to_table("snort.conf missing argument for " +
opt_name + " <int>");
return false;
}
if(!keyword.compare("default"))
{
- converter->open_table("http_server");
+ cv->open_table("http_server");
}
else
{
- converter->open_table("http_server_" + std::to_string(binding_id));
+ cv->open_table("http_server_" + std::to_string(binding_id));
binding_id++;
// CREATE A BINDING HERE!!
}
bool tmpval = true;
if (!keyword.compare("extended_response_inspection"))
- tmpval = converter->add_option_to_table("extended_response_inspection", true);
+ tmpval = cv->add_option_to_table("extended_response_inspection", true);
else if (!keyword.compare("allow_proxy_use"))
- tmpval = converter->add_option_to_table("allow_proxy_use", true);
+ tmpval = cv->add_option_to_table("allow_proxy_use", true);
else if (!keyword.compare("inspect_gzip"))
- tmpval = converter->add_option_to_table("inspect_gzip", true);
+ tmpval = cv->add_option_to_table("inspect_gzip", true);
else if (!keyword.compare("unlimited_decompress"))
- tmpval = converter->add_option_to_table("unlimited_decompress", true);
+ tmpval = cv->add_option_to_table("unlimited_decompress", true);
else if (!keyword.compare("normalize_javascript"))
- tmpval = converter->add_option_to_table("normalize_javascript", true);
+ tmpval = cv->add_option_to_table("normalize_javascript", true);
else if (!keyword.compare("enable_xff"))
- tmpval = converter->add_option_to_table("enable_xff", true);
+ tmpval = cv->add_option_to_table("enable_xff", true);
else if (!keyword.compare("extended_ascii_uri"))
- tmpval = converter->add_option_to_table("extended_ascii_uri", true);
+ tmpval = cv->add_option_to_table("extended_ascii_uri", true);
else if (!keyword.compare("non_strict"))
- tmpval = converter->add_option_to_table("non_strict", true);
+ tmpval = cv->add_option_to_table("non_strict", true);
else if (!keyword.compare("inspect_uri_only"))
- tmpval = converter->add_option_to_table("inspect_uri_only", true);
+ tmpval = cv->add_option_to_table("inspect_uri_only", true);
else if (!keyword.compare("tab_uri_delimiter"))
- tmpval = converter->add_option_to_table("tab_uri_delimiter", true);
+ tmpval = cv->add_option_to_table("tab_uri_delimiter", true);
else if (!keyword.compare("normalize_headers"))
- tmpval = converter->add_option_to_table("normalize_headers", true);
+ tmpval = cv->add_option_to_table("normalize_headers", true);
else if (!keyword.compare("normalize_utf"))
- tmpval = converter->add_option_to_table("normalize_utf", true);
+ tmpval = cv->add_option_to_table("normalize_utf", true);
else if (!keyword.compare("log_uri"))
- tmpval = converter->add_option_to_table("log_uri", true);
+ tmpval = cv->add_option_to_table("log_uri", true);
else if (!keyword.compare("normalize_cookies"))
- tmpval = converter->add_option_to_table("normalize_cookies", true);
+ tmpval = cv->add_option_to_table("normalize_cookies", true);
else if (!keyword.compare("log_hostname"))
- tmpval = converter->add_option_to_table("log_hostname", true);
+ tmpval = cv->add_option_to_table("log_hostname", true);
else if (!keyword.compare("no_pipeline_req"))
- tmpval = converter->add_option_to_table("no_pipeline_req", true);
+ tmpval = cv->add_option_to_table("no_pipeline_req", true);
else if (!keyword.compare("ascii"))
tmpval = parse_yn_bool_option("ascii", data_stream);
tmpval = parse_int_option("max_headers", data_stream);
else if (!keyword.compare("no_alerts"))
- converter->add_deprecated_comment("no_alerts");
+ cv->add_deprecated_comment("no_alerts");
else if (!keyword.compare("decompress_swf"))
tmpval = parse_bracketed_unsupported_list("decompress_swf", data_stream);
else if (!keyword.compare("non_rfc_char"))
{
- converter->add_deprecated_comment("non_rfc_char", "non_rfc_chars");
+ cv->add_deprecated_comment("non_rfc_char", "non_rfc_chars");
parse_bracketed_byte_list("non_rfc_chars", data_stream);
}
else if (!keyword.compare("enable_cookie"))
{
- tmpval = converter->add_option_to_table("enable_cookies", true);
- converter->add_deprecated_comment("enable_cookie", "enable_cookies");
+ tmpval = cv->add_option_to_table("enable_cookies", true);
+ cv->add_deprecated_comment("enable_cookie", "enable_cookies");
}
else if (!keyword.compare("flow_depth"))
{
- converter->add_deprecated_comment("flow_depth", "server_flow_depth");
+ cv->add_deprecated_comment("flow_depth", "server_flow_depth");
tmpval = parse_int_option("server_flow_depth", data_stream);
}
else if (!keyword.compare("ports"))
{
- converter->add_deprecated_comment("ports", "bindings");
- converter->add_comment_to_table("check bindings table for port information");
+ cv->add_deprecated_comment("ports", "bindings");
+ cv->add_comment_to_table("check bindings table for port information");
tmpval = parse_bracketed_unsupported_list("ports", data_stream);
}
}
else
{
- converter->open_table("small_chunk_length");
- converter->add_option_to_table("size", length);
- converter->add_option_to_table("count", consec_chunks);
- converter->close_table();
+ cv->open_table("small_chunk_length");
+ cv->add_option_to_table("size", length);
+ cv->add_option_to_table("count", consec_chunks);
+ cv->close_table();
}
}
if( (data_stream >> map_file) &&
(data_stream >> code_page))
{
- converter->open_table("iis_unicode_map");
- tmpval = converter->add_option_to_table("map_file", map_file);
- tmpval = converter->add_option_to_table("code_page", code_page) && tmpval;
- converter->close_table();
+ cv->open_table("iis_unicode_map");
+ tmpval = cv->add_option_to_table("map_file", map_file);
+ tmpval = cv->add_option_to_table("code_page", code_page) && tmpval;
+ cv->close_table();
}
else
{
- converter->add_comment_to_table("snort.conf missing argument for "
+ cv->add_comment_to_table("snort.conf missing argument for "
"iis_unicode_map <filename> <codemap>");
tmpval = false;
}
{
if (data_stream >> keyword)
{
- tmpval = converter->add_option_to_table("profile", keyword);
+ tmpval = cv->add_option_to_table("profile", keyword);
}
else
{
- converter->add_comment_to_table("Unable to convert keyword 'profile'");
+ cv->add_comment_to_table("Unable to convert keyword 'profile'");
tmpval = false;
}
}
std::string keyword;
bool retval = true;
- converter->open_table("normalize");
- converter->open_table("ip4");
- converter->add_option_to_table("base", true);
+ cv->open_table("normalize");
+ cv->open_table("ip4");
+ cv->add_option_to_table("base", true);
while( data_stream >> keyword)
{
if(!keyword.compare("df"))
- retval = converter->add_option_to_table("df", true) && retval;
+ retval = cv->add_option_to_table("df", true) && retval;
else if(!keyword.compare("rf"))
- retval = converter->add_option_to_table("rf", true) && retval;
+ retval = cv->add_option_to_table("rf", true) && retval;
else if(!keyword.compare("tos"))
- retval = converter->add_option_to_table("tos", true) && retval;
+ retval = cv->add_option_to_table("tos", true) && retval;
else if(!keyword.compare("trim"))
- retval = converter->add_option_to_table("trim", true) && retval;
+ retval = cv->add_option_to_table("trim", true) && retval;
else
retval = false;
}
- converter->close_table();
- converter->close_table();
+ cv->close_table();
+ cv->close_table();
return retval;
}
bool TcpNormalizer::set_ecn_w_comment(std::string comment)
{
- converter->add_comment_to_table("tcp normalizer: '" +
+ cv->add_comment_to_table("tcp normalizer: '" +
comment + "'' is deprecated. use 'ecn' instead");
- return converter->add_option_to_table("ecn", true);
+ return cv->add_option_to_table("ecn", true);
}
bool TcpNormalizer::set_base_w_comment(std::string comment)
{
- converter->add_comment_to_table("tcp normalizer: '" +
+ cv->add_comment_to_table("tcp normalizer: '" +
comment + "'' is deprecated. use 'base' instead");
- return converter->add_option_to_table("base", true);
+ return cv->add_option_to_table("base", true);
}
bool TcpNormalizer::set_trim_w_comment(std::string comment)
{
- converter->add_comment_to_table("tcp normalizer: '" +
+ cv->add_comment_to_table("tcp normalizer: '" +
comment + "'' is deprecated. use 'trim' instead");
- return converter->add_option_to_table("trim", true);
+ return cv->add_option_to_table("trim", true);
}
std::string value;
bool retval = true;
- converter->open_table("normalize");
- converter->open_table("tcp");
- converter->add_option_to_table("base", true);
+ cv->open_table("normalize");
+ cv->open_table("tcp");
+ cv->add_option_to_table("base", true);
while( data_stream >> keyword)
{
retval = set_base_w_comment("req_urp") && retval;
else if(!keyword.compare("ips"))
- retval = converter->add_option_to_table("ips", true) && retval;
+ retval = cv->add_option_to_table("ips", true) && retval;
else if(!keyword.compare("trim_syn"))
retval = set_trim_w_comment("trim_syn") && retval;
retval = set_trim_w_comment("trim_mss") && retval;
else if(!keyword.compare("trim"))
- retval = converter->add_option_to_table("trim", true) && retval;
+ retval = cv->add_option_to_table("trim", true) && retval;
else if(!keyword.compare("opts"))
- retval = converter->add_option_to_table("opts", true) && retval;
+ retval = cv->add_option_to_table("opts", true) && retval;
else if(!keyword.compare("urp"))
- retval = converter->add_option_to_table("urp", true) && retval;
+ retval = cv->add_option_to_table("urp", true) && retval;
else if(!keyword.compare("ecn"))
{
retval = false;
}
- converter->close_table();
- converter->close_table();
+ cv->close_table();
+ cv->close_table();
return retval;
}
prev = prev + ' ' + elem;
prev = prev + "]";
- return converter->add_option_to_table(list_name, prev);
+ return cv->add_option_to_table(list_name, prev);
}
bool PortScan::parse_list(std::string list_name, std::stringstream& data_stream)
return false;
while (data_stream >> elem && elem != "}")
- retval && converter->add_list_to_table(list_name, elem) && retval;
+ retval && cv->add_list_to_table(list_name, elem) && retval;
return retval;
}
return false;
while (data_stream >> elem && elem != "}")
- retval && converter->add_option_to_table(list_name, elem) && retval;
+ retval && cv->add_option_to_table(list_name, elem) && retval;
return retval;
}
if (!(data_stream >> val))
return false;
- converter->close_table();
- converter->open_table("port_scan_global");
- bool retval = converter->add_option_to_table(name, val);
- converter->close_table();
- converter->open_table("port_scan");
+ cv->close_table();
+ cv->open_table("port_scan_global");
+ bool retval = cv->add_option_to_table(name, val);
+ cv->close_table();
+ cv->open_table("port_scan");
if (!(data_stream >> garbage) || (garbage != "}"))
return false;
{
std::string keyword;
bool retval = true;
- converter->open_table("port_scan");
+ cv->open_table("port_scan");
while(data_stream >> keyword)
{
tmpval = parse_ip_list("ignore_scanned", data_stream);
else if(!keyword.compare("include_midstream"))
- tmpval = converter->add_option_to_table("include_midstream", true);
+ tmpval = cv->add_option_to_table("include_midstream", true);
else if(!keyword.compare("disabled"))
- converter->add_deprecated_comment("disabled");
+ cv->add_deprecated_comment("disabled");
else if(!keyword.compare("detect_ack_scans"))
- converter->add_deprecated_comment("detect_ack_scans");
+ cv->add_deprecated_comment("detect_ack_scans");
else if(!keyword.compare("logfile"))
- converter->add_deprecated_comment("logfile");
+ cv->add_deprecated_comment("logfile");
else if(!keyword.compare("memcap"))
tmpval = add_portscan_global_option("memcap", data_stream);
else if(!keyword.compare("proto"))
{
- converter->add_deprecated_comment("proto", "protos");
+ cv->add_deprecated_comment("proto", "protos");
retval = parse_curly_bracket_list("protos", data_stream) && retval;
}
else if(!keyword.compare("scan_type"))
{
- converter->add_deprecated_comment("scan_type", "scan_types");
+ cv->add_deprecated_comment("scan_type", "scan_types");
tmpval = parse_curly_bracket_list("scan_types", data_stream) && retval;
}
}
- converter->close_table(); // unecessary since the state will be reset
+ cv->close_table(); // unecessary since the state will be reset
return retval;
}
const ConvertMap* map = util::find_map(output_api, keyword);
if (map)
{
- converter->set_state(map->ctor(converter));
+ cv->set_state(map->ctor(converter));
return true;
}
}
std::string keyword;
bool retval = true;
- converter->open_table("stream");
+ cv->open_table("stream");
while(data_stream >> keyword)
{
if(!keyword.compare("flush_on_alert"))
- converter->add_deprecated_comment("flush_on_alert");
+ cv->add_deprecated_comment("flush_on_alert");
else if(!keyword.compare("disabled"))
- converter->add_deprecated_comment("disabled");
+ cv->add_deprecated_comment("disabled");
else if(!keyword.compare("track_tcp"))
{
- converter->add_deprecated_comment("track_tcp");
+ cv->add_deprecated_comment("track_tcp");
if(!(data_stream >> keyword)) // eat the yes/no option
tmpval = false;
}
else if(!keyword.compare("track_udp"))
{
- converter->add_deprecated_comment("track_udp");
+ cv->add_deprecated_comment("track_udp");
if(!(data_stream >> keyword)) // eat the yes/no option
tmpval = false;
}
else if(!keyword.compare("track_icmp"))
{
- converter->add_deprecated_comment("track_icmp");
+ cv->add_deprecated_comment("track_icmp");
if(!(data_stream >> keyword)) // eat the yes/no option
tmpval = false;
}
else if(!keyword.compare("prune_log_max"))
{
- converter->add_deprecated_comment("prune_log_max", "histogram");
+ cv->add_deprecated_comment("prune_log_max", "histogram");
if(!(data_stream >> keyword)) // eat the number of bytes
tmpval = false;
}
else if(!keyword.compare("max_tcp"))
{
- converter->open_table("tcp_cache");
+ cv->open_table("tcp_cache");
tmpval = parse_int_option("max_sessions", data_stream);
- converter->close_table();
+ cv->close_table();
}
else if(!keyword.compare("memcap"))
{
- converter->open_table("tcp_cache");
+ cv->open_table("tcp_cache");
tmpval = parse_int_option("memcap", data_stream);
- converter->close_table();
+ cv->close_table();
}
else if(!keyword.compare("max_udp"))
{
- converter->open_table("udp_cache");
+ cv->open_table("udp_cache");
tmpval = parse_int_option("max_sessions", data_stream);
- converter->close_table();
+ cv->close_table();
}
else if(!keyword.compare("max_icmp"))
{
- converter->open_table("icmp_cache");
+ cv->open_table("icmp_cache");
tmpval = parse_int_option("max_sessions", data_stream);
- converter->close_table();
+ cv->close_table();
}
else if(!keyword.compare("show_rebuilt_packets"))
{
- converter->open_top_level_table("stream_tcp");
- converter->add_option_to_table("show_rebuilt_packets", true);
- converter->close_table();
+ cv->open_top_level_table("stream_tcp");
+ cv->add_option_to_table("show_rebuilt_packets", true);
+ cv->close_table();
}
else if(!keyword.compare("min_response_seconds"))
{
- converter->open_top_level_table("active");
+ cv->open_top_level_table("active");
tmpval = parse_int_option("min_interval", data_stream);
- converter->close_table();
+ cv->close_table();
}
else if(!keyword.compare("max_active_responses"))
{
- converter->open_top_level_table("active");
+ cv->open_top_level_table("active");
tmpval = parse_int_option("max_responses", data_stream);
- converter->close_table();
+ cv->close_table();
}
if (!(data_stream >> i_val))
return false;
- converter->open_table("small_segments");
- converter->add_option_to_table("count", i_val);
- converter->close_table();
+ cv->open_table("small_segments");
+ cv->add_option_to_table("count", i_val);
+ cv->close_table();
if (!(data_stream >> s_val))
return false;
if(!(data_stream >> i_val))
return false;
- converter->open_table("small_segments");
- converter->add_option_to_table("maximum_size", i_val);
- converter->close_table();
+ cv->open_table("small_segments");
+ cv->add_option_to_table("maximum_size", i_val);
+ cv->close_table();
if (!(data_stream >> s_val))
return false;
- converter->open_table("small_segments");
+ cv->open_table("small_segments");
while(data_stream >> s_val && (s_val.back() != ','))
- converter->add_list_to_table("ignore_ports", s_val);
+ cv->add_list_to_table("ignore_ports", s_val);
if (!s_val.empty())
{
s_val.pop_back();
- converter->add_list_to_table("ignore_ports", s_val);
+ cv->add_list_to_table("ignore_ports", s_val);
}
- converter->close_table();
+ cv->close_table();
return true;
}
if( !opt_name.compare("client"))
{
- converter->add_deprecated_comment("port client", "client_ports");
+ cv->add_deprecated_comment("port client", "client_ports");
opt_name = "client_ports";
}
else if( !opt_name.compare("server"))
{
- converter->add_deprecated_comment("port server", "server_ports");
+ cv->add_deprecated_comment("port server", "server_ports");
opt_name = "server_ports";
}
else if( !opt_name.compare("both"))
{
- converter->add_deprecated_comment("port both", "both_ports");
+ cv->add_deprecated_comment("port both", "both_ports");
opt_name = "both_ports";
}
return false;
while(data_stream >> s_val && (s_val.back() != ','))
- retval = converter->add_list_to_table(opt_name, s_val) && retval;
+ retval = cv->add_list_to_table(opt_name, s_val) && retval;
if (!s_val.empty())
{
s_val.pop_back();
- converter->add_list_to_table(opt_name, s_val);
+ cv->add_list_to_table(opt_name, s_val);
}
return retval;
std::string keyword;
bool retval = true;
- converter->open_table("stream_tcp");
+ cv->open_table("stream_tcp");
while(data_stream >> keyword)
{
tmpval = parse_small_segments(data_stream);
else if(!keyword.compare("ignore_any_rules"))
- tmpval = converter->add_option_to_table("ignore_any_rules", true);
+ tmpval = cv->add_option_to_table("ignore_any_rules", true);
else if(!keyword.compare("ports"))
tmpval = parse_ports(data_stream);
else if(!keyword.compare("detect_anomalies"))
- converter->add_deprecated_comment("detect_anomalies");
+ cv->add_deprecated_comment("detect_anomalies");
else if(!keyword.compare("dont_store_large_packets"))
- converter->add_deprecated_comment("dont_store_large_packets");
+ cv->add_deprecated_comment("dont_store_large_packets");
else if(!keyword.compare("check_session_hijacking"))
- converter->add_deprecated_comment("check_session_hijacking");
+ cv->add_deprecated_comment("check_session_hijacking");
else if(!keyword.compare("bind_to"))
{
- converter->add_deprecated_comment("bind_to", "bindings");
+ cv->add_deprecated_comment("bind_to", "bindings");
if(!(data_stream >> keyword))
tmpval = false;
}
else if(!keyword.compare("dont_reassemble_async"))
{
- converter->add_deprecated_comment("dont_reassemble_async", "reassemble_async");
- tmpval = converter->add_option_to_table("reassemble_async", false);
+ cv->add_deprecated_comment("dont_reassemble_async", "reassemble_async");
+ tmpval = cv->add_option_to_table("reassemble_async", false);
}
else if(!keyword.compare("use_static_footprint_sizes"))
{
- converter->add_deprecated_comment("footprint", "use_static_footprint_sizes");
- tmpval = converter->add_option_to_table("footprint", true);
+ cv->add_deprecated_comment("footprint", "use_static_footprint_sizes");
+ tmpval = cv->add_option_to_table("footprint", true);
}
else if(!keyword.compare("timeout"))
{
- converter->add_deprecated_comment("timeout", "session_timeout");
+ cv->add_deprecated_comment("timeout", "session_timeout");
tmpval = parse_int_option("session_timeout", data_stream);
}
else if(!keyword.compare("max_queued_segs"))
{
- converter->add_deprecated_comment("max_queued_segs", "queue_limit.max_segments");
- converter->open_table("queue_limit");
+ cv->add_deprecated_comment("max_queued_segs", "queue_limit.max_segments");
+ cv->open_table("queue_limit");
tmpval = parse_int_option("max_segments", data_stream);
- converter->close_table();
+ cv->close_table();
}
else if(!keyword.compare("max_queued_bytes"))
{
- converter->add_deprecated_comment("max_queued_bytes", "queue_limit.max_bytes");
- converter->open_table("queue_limit");
+ cv->add_deprecated_comment("max_queued_bytes", "queue_limit.max_bytes");
+ cv->open_table("queue_limit");
tmpval = parse_int_option("max_bytes", data_stream);
- converter->close_table();
+ cv->close_table();
}
else
bool retval = true;
std::string keyword;
- converter->open_table("stream_udp");
+ cv->open_table("stream_udp");
while(data_stream >> keyword)
{
continue;
if(!keyword.compare("ignore_any_rules"))
- tmpval = converter->add_option_to_table("ignore_any_rules", true);
+ tmpval = cv->add_option_to_table("ignore_any_rules", true);
else if(!keyword.compare("timeout"))
{
- converter->add_deprecated_comment("timeout", "session_timeout");
+ cv->add_deprecated_comment("timeout", "session_timeout");
tmpval = parse_int_option("session_timeout", data_stream);
}
#include "init_state.h"
#include "snort2lua_util.h"
-static bool convert(std::ifstream& in, std::ofstream& out)
+static void convert(Converter *cv, std::string input_file)
{
- Converter cv;
- cv.reset_state();
+ std::ifstream in;
std::string orig_text;
+ in.open(input_file, std::ifstream::in);
+ cv->reset_state();
+
while(!in.eof())
{
std::string tmp;
if (orig_text.empty())
{
- cv.add_comment_to_file("");
+ cv->add_comment_to_file("");
}
else if (orig_text.front() == '#')
{
orig_text.erase(orig_text.begin());
- cv.add_comment_to_file(orig_text);
+ cv->add_comment_to_file(orig_text);
orig_text.clear();
}
else if ( orig_text.back() == '\\')
std::stringstream data_stream(orig_text);
while(data_stream.tellg() != -1)
{
- if (!cv.convert_line(data_stream))
+ if (!cv->convert_line(data_stream))
{
- cv.log_error("Failed to entirely convert: " + orig_text);
-// data_stream.setstate(std::basic_ios<char>::eofbit);
+ cv->log_error("Failed to entirely convert: " + orig_text);
break;
}
}
orig_text.clear();
- cv.reset_state();
+ cv->reset_state();
}
}
- // finally, lets print the converter to file
- out << "require(\"snort_config\") -- for loading" << std::endl;
- out << cv;
- return true;
}
{
std::ifstream in;
std::ofstream out;
+ std::string input_name, output_name;
+ Converter cv;
if (argc != 3)
{
return -1;
}
- in.open(argv[1], std::ifstream::in);
- out.open(argv[2], std::ifstream::out);
+ input_name = std::string(argv[1]);
+ output_name = std::string(argv[2]);
if (in.fail())
{
return -1;
}
- if (!convert(in, out))
- {
- std::cout << "Error: failed to convert files!" << std::endl;
- }
+ convert(&cv, input_name);
+
+
+ // finally, lets print the converter to file
+ out.open(argv[2], std::ifstream::out);
+ out << "require(\"snort_config\") -- for loading" << std::endl << std::endl;
+ out << cv;
in.close();
out.close();
projects / thirdparty / snort3.git / commitdiff
