class Alertfile : public ConversionState
{
public:
- Alertfile() : ConversionState() {};
+ Alertfile(Converter& c) : ConversionState(c) {};
virtual ~Alertfile() {};
virtual bool convert(std::istringstream& data_stream);
};
**************************/
-static ConversionState* ctor()
-{ return new Alertfile(); }
+static ConversionState* ctor(Converter& c)
+{ return new Alertfile(c); }
static const ConvertMap alertfile_api =
class Binding : public ConversionState
{
public:
- Binding() : ConversionState() {};
+ Binding(Converter& c) : ConversionState(c) {};
virtual ~Binding() {};
virtual bool convert(std::istringstream& data_stream);
void add_vlan(const std::string& vlan, Binder&);
void add_policy_id(const std::string& id, Binder&);
void add_net(const std::string& net, Binder&);
-
- // FIXIT-M Remove this functino after refactor
- bool parse_file(std::string file_name);
};
} // namespace
if (!util::get_string(data_stream, val, ","))
return false;
- Binder bind;
+ Binder bind(table_api);
bool rc = true;
do
// if we still can't find this file, add it as a snort file
if (util::file_exists(full_path))
+ {
+ Converter cv;
+
+ if (cv.convert(input_file, input_file + ".lua") < 0)
+ rc = false;
+
parse_file(full_path);
+ }
}
// FIXIT-L J this file extension shoudl not be hardcoded
return rc;
}
-
-// FIXIT-M J because the other refactor comments don't indicate how repetitive this code is
-bool Binding::parse_file(std::string input_file)
-{
- std::vector<Variable*> vars;
- std::vector<Table*> tables;
- std::vector<Rule*> rules;
- std::vector<Include*> includes;
- Comments comment("This file is a binding!!", 0,
- Comments::CommentType::MULTI_LINE);
- Comments* comment_ptr = &comment;
- bool rc = false;
-
- data_api.swap_conf_data(vars, includes, comment_ptr);
- table_api.swap_tables(tables);
- rule_api.swap_rules(rules);
-
-
-
- if (cv.convert_file(input_file) < 0)
- rc = true; // return a negative number to main snort2lua method
-
-
- if (!rule_api.empty())
- {
- table_api.open_top_level_table("ips");
- table_api.add_option("rules", "$default_rules");
- table_api.close_table();
- }
-
-
- // print configuration file
- if (!table_api.empty() || data_api.empty() || !rule_api.empty())
- {
-
-
- table_api.open_top_level_table("binder");
- table_api.close_table();
-
-
- std::ofstream out;
- out.open(input_file + ".lua");
-
-
- out << "require(\"snort_config\")\n\n";
- data_api.print_data(out);
- rule_api.print_rules(out, false);
- table_api.print_tables(out);
- data_api.print_comments(out);
- out << std::endl;
- out.close();
-
- }
-
-
- data_api.swap_conf_data(vars, includes, comment_ptr);
- table_api.swap_tables(tables);
- rule_api.swap_rules(rules);
- return rc;
-}
-
/**************************
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Binding();
+ return new Binding(c);
}
static const ConvertMap binding_api =
class ConfigChecksum : public ConversionState
{
public:
- ConfigChecksum( const std::string* snort_option,
+ ConfigChecksum( Converter& c,
+ const std::string* snort_option,
const std::string* lua_table,
const std::string* lua_option) :
- ConversionState(),
+ ConversionState(c),
snort_option(snort_option),
lua_table(lua_table),
lua_option(lua_option)
template<const std::string *snort_option,
const std::string *lua_name,
const std::string *lua_option = nullptr>
-static ConversionState* config_checksum_ctor()
+static ConversionState* config_checksum_ctor(Converter& c)
{
- return new ConfigChecksum(snort_option, lua_name, lua_option);
+ return new ConfigChecksum(c, snort_option, lua_name, lua_option);
}
class Classification : public ConversionState
{
public:
- Classification() : ConversionState() {}
+ Classification(Converter& c) : ConversionState(c) {}
virtual ~Classification() {}
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Classification();
+ return new Classification(c);
}
static const ConvertMap classification_api =
class DecodeEsp : public ConversionState
{
public:
- DecodeEsp() : ConversionState() {};
+ DecodeEsp(Converter& c) : ConversionState(c) {};
virtual ~DecodeEsp() {};
virtual bool convert(std::istringstream& data_stream);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new DecodeEsp();
+ return new DecodeEsp(c);
}
static const ConvertMap decode_esp_api =
class DefaultRuleState : public ConversionState
{
public:
- DefaultRuleState() : ConversionState() {};
+ DefaultRuleState(Converter& c) : ConversionState(c) {};
virtual ~DefaultRuleState() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new DefaultRuleState();
+ return new DefaultRuleState(c);
}
static const ConvertMap default_rule_state_api =
class Deleted : public ConversionState
{
public:
- Deleted() : ConversionState() {};
+ Deleted(Converter& c) : ConversionState(c) {};
virtual ~Deleted() {};
virtual bool convert(std::istringstream& data_stream);
};
}
template<const std::string *snort_option>
-static ConversionState* deleted_ctor()
+static ConversionState* deleted_ctor(Converter& c)
{
// set here since not all deleted configs have options
- if (!data_api.is_quiet_mode())
+ if (!DataApi::is_quiet_mode())
{
- table_api.open_table("deleted_snort_config_options");
- table_api.add_deleted_comment("config " + *snort_option + "[:.*]");
- table_api.close_table();
+ c.get_table_api().open_table("deleted_snort_config_options");
+ c.get_table_api().add_deleted_comment("config " + *snort_option + "[:.*]");
+ c.get_table_api().close_table();
}
- return new Deleted();
+ return new Deleted(c);
}
/*************************************************
class Detection : public ConversionState
{
public:
- Detection() : ConversionState() {};
+ Detection(Converter& c) : ConversionState(c) {};
virtual ~Detection() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Detection();
+ return new Detection(c);
}
static const ConvertMap detection_api =
class EventQueue : public ConversionState
{
public:
- EventQueue() : ConversionState() {};
+ EventQueue(Converter& c) : ConversionState(c) {};
virtual ~EventQueue() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new EventQueue();
+ return new EventQueue(c);
}
static const ConvertMap event_queue_api =
class EventTrace : public ConversionState
{
public:
- EventTrace() : ConversionState() {};
+ EventTrace(Converter& c) : ConversionState(c) {};
virtual ~EventTrace() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new EventTrace();
+ return new EventTrace(c);
}
static const ConvertMap event_trace_api =
class File : public ConversionState
{
public:
- File() : ConversionState() {};
+ File(Converter& c) : ConversionState(c) {};
virtual ~File() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new File();
+ return new File(c);
}
static const ConvertMap file_api =
class IgnorePorts : public ConversionState
{
public:
- IgnorePorts() : ConversionState() {};
+ IgnorePorts(Converter& c) : ConversionState(c) {};
virtual ~IgnorePorts() {};
virtual bool convert(std::istringstream& data_stream);
};
bool IgnorePorts::convert(std::istringstream& data_stream)
{
- Binder bind;
+ Binder bind(table_api);
bool retval = true;
std::string keyword;
std::string port;
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new IgnorePorts();
+ return new IgnorePorts(c);
}
static const ConvertMap config_ignore_ports =
class Ipv6Frag : public ConversionState
{
public:
- Ipv6Frag() : ConversionState() {};
+ Ipv6Frag(Converter& c) : ConversionState(c) {};
virtual ~Ipv6Frag() {};
virtual bool convert(std::istringstream& data_stream);
void Ipv6Frag::add_deleted_option(std::string dlt_opt)
{
// see comment in Ipv6Frag::convert
- if (!data_api.is_quiet_mode())
+ if (!DataApi::is_quiet_mode())
table_api.add_deleted_comment("config ipv6_frag: " + dlt_opt);
}
// I'm checking here because I do not want to create this
// table in quiet mode
- if (!data_api.is_quiet_mode())
+ if (!DataApi::is_quiet_mode())
table_api.open_table("deleted_snort_config_options");
while (util::get_string(data_stream, arg, ","))
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Ipv6Frag();
+ return new Ipv6Frag(c);
}
static const ConvertMap ipv6_frag_api =
class Memcap : public ConversionState
{
public:
- Memcap() : ConversionState() {};
+ Memcap(Converter& c) : ConversionState(c) {};
virtual ~Memcap() {};
virtual bool convert(std::istringstream& data_stream);
};
template<const std::string *snort_option,
const std::string* lua_table,
const std::string* lua_option>
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Memcap<snort_option, lua_table, lua_option>();
+ return new Memcap<snort_option, lua_table, lua_option>(c);
}
class MplsPayloadType : public ConversionState
{
public:
- MplsPayloadType() : ConversionState() {};
+ MplsPayloadType(Converter& c) : ConversionState(c) {};
virtual ~MplsPayloadType() {};
virtual bool convert(std::istringstream& data_stream);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new MplsPayloadType();
+ return new MplsPayloadType(c);
}
static const ConvertMap mpls_payload_type_api =
class DeadCode : public ConversionState
{
public:
- DeadCode() : ConversionState() {}
+ DeadCode(Converter& c) : ConversionState(c) {}
virtual ~DeadCode() {}
virtual bool convert(std::istringstream& data_stream)
{
template<const std::string* snort_option,
const std::string* lua_table,
const std::string* lua_option>
-static ConversionState* config_true_no_opt_ctor()
+static ConversionState* config_true_no_opt_ctor(Converter& c)
{
- table_api.open_table(*lua_table);
+ c.get_table_api().open_table(*lua_table);
if (snort_option->compare(*lua_option))
- table_api.add_diff_option_comment("config " + *snort_option + ":", *lua_option);
+ {
+ c.get_table_api().add_diff_option_comment(
+ "config " + *snort_option + ":", *lua_option);
+ }
- table_api.add_option(*lua_option, true);
- table_api.close_table();
- return new DeadCode();
+ c.get_table_api().add_option(*lua_option, true);
+ c.get_table_api().close_table();
+ return new DeadCode(c);
}
template<const std::string* snort_option,
const std::string* lua_table>
-static ConversionState* config_true_no_opt_ctor()
+static ConversionState* config_true_no_opt_ctor(Converter& c)
{
- table_api.open_table(*lua_table);
- table_api.add_option(*snort_option, true);
- table_api.close_table();
- return new DeadCode();
+ c.get_table_api().open_table(*lua_table);
+ c.get_table_api().add_option(*snort_option, true);
+ c.get_table_api().close_table();
+ return new DeadCode(c);
}
template<const std::string* snort_option,
const std::string* lua_table,
const std::string* lua_option>
-static ConversionState* config_false_no_opt_ctor()
+static ConversionState* config_false_no_opt_ctor(Converter& c)
{
- table_api.open_table(*lua_table);
+ c.get_table_api().open_table(*lua_table);
// WARNING: THIS WILL SEGFAULT if any variable is nullptr!!
if (snort_option->compare(*lua_option))
- table_api.add_diff_option_comment("config " + *snort_option + ":", *lua_option);
+ c.get_table_api().add_diff_option_comment("config " + *snort_option + ":", *lua_option);
- table_api.add_option(*lua_option, false);
- table_api.close_table();
- return new DeadCode();
+ c.get_table_api().add_option(*lua_option, false);
+ c.get_table_api().close_table();
+ return new DeadCode(c);
}
template<const std::string* snort_option,
const std::string* lua_table>
-static ConversionState* config_false_no_opt_ctor()
+static ConversionState* config_false_no_opt_ctor(Converter& c)
{
- table_api.open_table(*lua_table);
- table_api.add_option(*snort_option, false);
- table_api.close_table();
- return new DeadCode();
+ c.get_table_api().open_table(*lua_table);
+ c.get_table_api().add_option(*snort_option, false);
+ c.get_table_api().close_table();
+ return new DeadCode(c);
}
} // namespace
class ConfigIntOption : public ConversionState
{
public:
- ConfigIntOption( const std::string* snort_option,
- const std::string* lua_table,
- const std::string* lua_option) :
- ConversionState(),
+ ConfigIntOption(Converter& c,
+ const std::string* snort_option,
+ const std::string* lua_table,
+ const std::string* lua_option) :
+ ConversionState(c),
snort_option(snort_option),
lua_table(lua_table),
lua_option(lua_option)
(lua_table == nullptr)||
(lua_table->empty()))
{
- data_api.developer_error("Invalid Option!! Missing either the Snort Option"
+ DataApi::developer_error("Invalid Option!! Missing either the Snort Option"
" or the corresponding lua table!!");
return false;
}
template<const std::string *snort_option,
const std::string *lua_table,
const std::string *lua_option = nullptr>
-static ConversionState* config_int_ctor()
+static ConversionState* config_int_ctor(Converter& c)
{
- return new ConfigIntOption( snort_option,
+ return new ConfigIntOption( c,
+ snort_option,
lua_table,
lua_option);
}
class ConfigStringOption : public ConversionState
{
public:
- ConfigStringOption( const std::string* snort_option,
+ ConfigStringOption( Converter& c,
+ const std::string* snort_option,
const std::string* lua_table,
const std::string* lua_option) :
- ConversionState(),
+ ConversionState(c),
snort_option(snort_option),
lua_table(lua_table),
lua_option(lua_option)
template<const std::string *snort_option,
const std::string *lua_table,
const std::string *lua_option = nullptr>
-static ConversionState* config_string_ctor()
+static ConversionState* config_string_ctor(Converter& c)
{
- return new ConfigStringOption( snort_option,
+ return new ConfigStringOption( c,
+ snort_option,
lua_table,
lua_option);
}
class Order : public ConversionState
{
public:
- Order() : ConversionState() {};
+ Order(Converter& c) : ConversionState(c) {};
virtual ~Order() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Order();
+ return new Order(c);
}
static const ConvertMap order_api =
class PafMax : public ConversionState
{
public:
- PafMax() : ConversionState() {};
+ PafMax(Converter& c) : ConversionState(c) {};
virtual ~PafMax() {};
virtual bool convert(std::istringstream& data_stream);
};
if (data_stream >> val)
{
if (val < 1460)
- retval = table_api.add_diff_option_comment("paf_max [0:63780]", "paf_max [1460:63780]");
+ table_api.add_diff_option_comment("paf_max [0:63780]", "max_pdu [1460:63780]");
else
- retval = table_api.add_option("paf_max", val);
+ retval = table_api.add_option("max_pdu", val);
}
else
- retval = false;
+ data_api.failed_conversion(data_stream);
table_api.close_table();
return retval;
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new PafMax();
-}
+static ConversionState* ctor(Converter& c)
+{ return new PafMax(c); }
static const ConvertMap paf_max_api =
{
class Ppm : public ConversionState
{
public:
- Ppm() : ConversionState() {};
+ Ppm(Converter& c) : ConversionState(c) {};
virtual ~Ppm() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Ppm();
+ return new Ppm(c);
}
static const ConvertMap config_ppm_api =
class Profilers : public ConversionState
{
public:
- Profilers() : ConversionState() {};
+ Profilers(Converter& c) : ConversionState(c) {};
virtual ~Profilers() {};
virtual bool convert(std::istringstream& data_stream);
};
}
template<const std::string* table_name>
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Profilers<table_name>();
+ return new Profilers<table_name>(c);
}
/**************************
class Reference : public ConversionState
{
public:
- Reference() : ConversionState() {};
+ Reference(Converter& c) : ConversionState(c) {};
virtual ~Reference() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Reference();
+ return new Reference(c);
}
static const ConvertMap reference_api =
class Response : public ConversionState
{
public:
- Response() : ConversionState() {};
+ Response(Converter& c) : ConversionState(c) {};
virtual ~Response() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Response();
+ return new Response(c);
}
static const ConvertMap response_api =
class TunnelVerdicts : public ConversionState
{
public:
- TunnelVerdicts() : ConversionState() {};
+ TunnelVerdicts(Converter& c) : ConversionState(c) {};
virtual ~TunnelVerdicts() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new TunnelVerdicts();
+ return new TunnelVerdicts(c);
}
static const ConvertMap tunnel_verdicts_api =
*/
class ConversionState;
-typedef ConversionState* (*conv_new_f)(void);
+class Converter;
+typedef ConversionState* (*conv_new_f)(Converter&);
struct ConvertMap
{
#include <iostream>
#include "data/dt_data.h"
+#include "data/dt_table_api.h"
+#include "data/dt_rule_api.h"
// the following three files are for the function 'set_next_rule_state'
#include "utils/s2l_util.h"
#include "utils/converter.h"
#include "conversion_defines.h"
+class DataApi;
+class RuleApi;
+class TableApi;
class ConversionState
{
public:
- ConversionState() {}
-
+ ConversionState(Converter& c) : cv(c),
+ data_api(c.get_data_api()),
+ table_api(c.get_table_api()),
+ rule_api(c.get_rule_api())
+ { }
virtual ~ConversionState() {};
virtual bool convert(std::istringstream& data)=0;
+
protected:
+ Converter& cv;
+ DataApi& data_api;
+ TableApi& table_api;
+ RuleApi& rule_api;
#if 0
Forward declaration fo parsing methods. Since these are all inline,
if (map)
{
rule_api.unselect_option(); // reset option data...just in case.
- cv.set_state(map->ctor());
+ cv.set_state(map->ctor(cv));
break;
}
else
}
}
- // This is definitely a special case to always return true, I have
- // already taken corrective action by signifyig this is a 'bad rule'.
- // Additionally, I don't return false earlier becasue, when possible,
- // I want to parse the entire rule. If I only return false when the
- // last option was invalid, this would lead to an incosistant and
- // unreliable return value. Bottom line, I'm consistant by returning
- // true and handling "bad" values and directly signifgying to Data
- // classes this is a bad rule.
+ /*
+ * The reason this function always returns true is because if the
+ * function returned false, the main conversion loop would stop
+ * converting. However, every part of the rule which can be
+ * converted, should be converted. Therefore, this function
+ * takes its own invalid conversion action by calling bad_rule(),
+ * and then returns true.
+ */
return true;
}
void Comments::add_text(std::string text)
{
- // if this line is not an empty string
- // OR the previous line was not an empty string
- if (!text.empty() || !prev_empty)
+ if ( !(text.empty() && prev_empty) )
{
comment.push_back(std::string(text));
prev_empty = text.empty();
comment.push_back(new_text);
}
-bool Comments::empty()
+bool Comments::empty() const
{
return ((comment.size() == 0) ||
(comment.size() == 1 && header));
static const std::string start_comments =
"\nCOMMENTS:\n"
" these line were commented "
- "in the configuration file.";
+ "in the configuration file.\n\n";
static const std::string start_errors =
"\nERRORS:\n"
// insert this string before the first lexigraphically larger string.
// will not add duplicates.
void add_sorted_text(std::string new_text);
- bool empty();
+ bool empty() const;
// overloading operators
friend std::ostream &operator<<( std::ostream&, const Comments &);
bool first_line = true;
// don't print comment and tag in quiet mode
- if (!data_api.is_quiet_mode())
+ if (!DataApi::is_quiet_mode())
{
if (rule.is_bad_rule)
out << "#FAILED TO CONVERT THE FOLLOWING RULE:" << "\n";
out << whitespace << t.name << " =" << std::endl;
out << whitespace << '{' << std::endl;
- if (!t.comments->empty() && !data_api.is_quiet_mode())
+ if (!t.comments->empty() && !DataApi::is_quiet_mode())
out << (*t.comments) << std::endl;
// if we only want differences, don't print data
- if (!data_api.is_difference_mode())
+ if (!DataApi::is_difference_mode())
{
for (Option* o : t.options)
out << (*o) << ",\n";
Variable::~Variable(){}
-std::string Variable::get_value(LuaData* ld)
+std::string Variable::get_value(DataApi* ld)
{
std::string variable = "";
bool first_line = true;
#ifndef DATA_DATA_TYPES_DT_VAR_H
#define DATA_DATA_TYPES_DT_VAR_H
-class LuaData;
+class DataApi;
class Variable
{
virtual ~Variable();
inline std::string get_name(){ return name; };
- std::string get_value(LuaData*);
+ std::string get_value(DataApi*);
bool add_value(std::string);
friend std::ostream &operator<<( std::ostream&, const Variable &);
#include "data/data_types/dt_rule.h"
#include "data/data_types/dt_include.h"
-LuaData data_api;
+DataApi::PrintMode DataApi::mode = DataApi::PrintMode::DEFAULT;
+unsigned int DataApi::dev_warnings = 0;
-
-LuaData::LuaData()
- : mode(LuaData::PrintMode::QUIET),
- curr_data_bad(false)
+DataApi::DataApi() : curr_data_bad(false)
{
comments = new Comments(start_comments, 0,
Comments::CommentType::MULTI_LINE);
Comments::CommentType::MULTI_LINE);
}
-LuaData::~LuaData()
+DataApi::~DataApi()
{
for (auto v : vars)
delete v;
-std::string LuaData::translate_variable(const std::string& var_name)
+std::string DataApi::translate_variable(const std::string& var_name)
{
for (auto v : vars)
if (!var_name.compare(v->get_name()))
* Given a Snort style string to expand, this funcion will return
* the expanded string
*/
-std::string LuaData::expand_vars(const std::string &string)
+std::string DataApi::expand_vars(const std::string &string)
{
std::string estring;
estring.resize(1024, '\0');
return estring;
}
-bool LuaData::failed_conversions()
-{ return !errors->empty(); }
+bool DataApi::failed_conversions() const
+{ return !errors->empty() || dev_warnings > 0; }
-void LuaData::failed_conversion(const std::istringstream& stream)
+void DataApi::failed_conversion(const std::istringstream& stream)
{
// we only need to go through this once.
if (!curr_data_bad)
}
}
-void LuaData::failed_conversion(const std::istringstream& stream,
+void DataApi::failed_conversion(const std::istringstream& stream,
const std::string unkown_option)
{
// we only need to go through this once.
}
-bool LuaData::add_variable(std::string name, std::string value)
+bool DataApi::add_variable(std::string name, std::string value)
{
for (auto v : vars)
if (!name.compare(v->get_name()))
}
-void LuaData::reset_state()
+void DataApi::reset_state()
{
curr_data_bad = false;
}
-bool LuaData::add_include_file(std::string file_name)
+bool DataApi::add_include_file(std::string file_name)
{
Include* incl = new Include(file_name);
return true;
}
-void LuaData::developer_error(std::string error_string)
+void DataApi::developer_error(std::string error_string)
{
+ dev_warnings++;
std::cout << "RUNTIME ERROR: " << error_string << std::endl;
}
-void LuaData::add_comment(std::string c)
+void DataApi::add_comment(std::string c)
{ comments->add_text(c); }
-void LuaData::print_errors(std::ostream& out)
+void DataApi::print_errors(std::ostream& out)
{
if (is_default_mode() &&
!errors->empty())
}
}
-void LuaData::print_data(std::ostream& out)
+void DataApi::print_data(std::ostream& out)
{
for (Variable* v : vars)
out << (*v) << "\n\n";
}
-void LuaData::print_comments(std::ostream& out)
+void DataApi::print_comments(std::ostream& out)
{
if (is_default_mode() &&
!comments->empty())
out << (*comments) << "\n";
}
-void LuaData::swap_conf_data(std::vector<Variable*>& new_vars,
+void DataApi::swap_conf_data(std::vector<Variable*>& new_vars,
std::vector<Include*>& new_includes,
Comments*& new_comments)
{
* creating new convesion states. There are comments in
* in all caps which show the seperate the sections.
*
- * The first section of this file is really LuaData creation
+ * The first section of this file is really DataApi creation
* and initialization, and adding miscelaneous objects
- * to the LuaData data. The second section is for creating
+ * to the DataApi data. The second section is for creating
* tables and their options. The third section is for
* creating rules.
*/
class Include;
class Variable;
class Comments;
-class LuaData;
-extern LuaData data_api;
+class DataApi;
-class LuaData
+class DataApi
{
public:
- LuaData();
- virtual ~LuaData();
+ DataApi();
+ virtual ~DataApi();
// set and retrieve various pieces of information from this Data object
// getters are for other data classes.
- inline void set_default_print() {mode = PrintMode::DEFAULT; }
- inline bool is_default_mode() { return mode == PrintMode::DEFAULT; }
- inline void set_quiet_print() {mode = PrintMode::QUIET; }
- inline bool is_quiet_mode() { return mode == PrintMode::QUIET; }
- inline void set_difference_print() {mode = PrintMode::DIFFERENCES; }
- inline bool is_difference_mode() { return mode == PrintMode::DIFFERENCES; }
+ inline static void set_default_print() {mode = PrintMode::DEFAULT; }
+ inline static bool is_default_mode() { return mode == PrintMode::DEFAULT; }
+ inline static void set_quiet_print() {mode = PrintMode::QUIET; }
+ inline static bool is_quiet_mode() { return mode == PrintMode::QUIET; }
+ inline static void set_difference_print() {mode = PrintMode::DIFFERENCES; }
+ inline static bool is_difference_mode() { return mode == PrintMode::DIFFERENCES; }
+
+ // For problems with the Snort2Lua code, NOT with the snort configuration
+ static void developer_error(std::string comment);
// given a Snort-style string, replace all of the variables with their values.
std::string expand_vars(const std::string&);
void print_errors(std::ostream&);
void print_data(std::ostream&);
void print_comments(std::ostream& out);
- // For problems with the Snort2Lua code, NOT with the snort configuration
- void developer_error(std::string comment);
// have there been any failed conversion?
- bool failed_conversions();
+ bool failed_conversions() const;
// is there any actual data to print?
bool empty()
{ return (vars.size() != 0 || includes.size() != 0);}
};
// actual configuration information
- PrintMode mode;
+ static PrintMode mode;
+ static unsigned int dev_warnings;
+
std::vector<Variable*> vars;
std::vector<Include*> includes;
Comments* comments;
#include "data/data_types/dt_rule_suboption.h"
-RuleApi rule_api;
-
RuleApi::RuleApi()
: curr_rule(nullptr),
curr_data_bad(false)
curr_data_bad = false;
}
-bool RuleApi::failed_conversions()
+bool RuleApi::failed_conversions() const
{ return !bad_rules->empty(); }
void RuleApi::begin_rule()
if (!curr_rule_opt)
{
- data_api.developer_error("Select an option before placing a "
+ DataApi::developer_error("Select an option before placing a "
"new option before selected option");
return false;
}
if (curr_rule_opt)
return curr_rule_opt->add_suboption(keyword);
- data_api.developer_error("Select an option before adding a suboption!!");
+ DataApi::developer_error("Select an option before adding a suboption!!");
return false;
}
if (curr_rule_opt)
return curr_rule_opt->add_suboption(keyword, val);
- data_api.developer_error("Select an option before adding a suboption!!");
+ DataApi::developer_error("Select an option before adding a suboption!!");
return false;
}
if (curr_rule_opt != nullptr)
return true;
else
- data_api.developer_error("Option " + opt_name + "never created for following rule:");
+ DataApi::developer_error("Option " + opt_name + "never created for following rule:");
}
else
{
- data_api.developer_error("Must begin a rule before selecting an option!");
+ DataApi::developer_error("Must begin a rule before selecting an option!");
}
return false;
std::ostream& operator<<( std::ostream &out, const RuleApi& data)
{
- if (data_api.is_default_mode())
+ if (DataApi::is_default_mode())
{
if (!data.bad_rules->empty())
out << (*data.bad_rules) << "\n";
void RuleApi::print_rejects(std::ostream& out)
{
- if (data_api.is_default_mode())
+ if (DataApi::is_default_mode())
{
if (!bad_rules->empty())
out << (*bad_rules) << "\n\n";
* creating new convesion states. There are comments in
* in all caps which show the seperate the sections.
*
- * The first section of this file is really LuaData creation
+ * The first section of this file is really DataApi creation
* and initialization, and adding miscelaneous objects
- * to the LuaData data. The second section is for creating
+ * to the DataApi data. The second section is for creating
* tables and their options. The third section is for
* creating rules.
*/
class RuleOption;
class Comments;
class RuleApi;
-extern RuleApi rule_api;
-
class RuleApi
virtual ~RuleApi();
- bool failed_conversions();
+ bool failed_conversions() const;
inline bool empty()
{ return (rules.size() == 0); }
-TableApi table_api;
-
-
TableApi::TableApi() : curr_data_bad(false) {}
// if no open tables, create a top-level table
if (open_tables.size() == 0)
{
- data_api.developer_error("A nameless table must be nested inside a table!!");
+ DataApi::developer_error("A nameless table must be nested inside a table!!");
}
else
{
void TableApi::close_table()
{
if (open_tables.size() == 0)
- data_api.developer_error("No open tables to close!!");
+ DataApi::developer_error("No open tables to close!!");
else
open_tables.pop();
}
{
if(open_tables.size() == 0)
{
- data_api.developer_error("Must open table before adding an option!!: " +
+ DataApi::developer_error("Must open table before adding an option!!: " +
option_name + " = " + val);
return false;
}
{
if(open_tables.size() == 0)
{
- data_api.developer_error("Must open table before adding an option!!: " +
+ DataApi::developer_error("Must open table before adding an option!!: " +
option_name + " = " + std::to_string(val));
return false;
}
{
if(open_tables.size() == 0)
{
- data_api.developer_error("Must open table before adding an option!!: " +
+ DataApi::developer_error("Must open table before adding an option!!: " +
option_name + " = " + std::to_string(val));
return false;
}
{
if(open_tables.size() == 0)
{
- data_api.developer_error("Must open table before adding an option!!: " +
+ DataApi::developer_error("Must open table before adding an option!!: " +
list_name + " = " + next_elem);
return false;
}
}
else
{
- data_api.developer_error("Must open table before adding an list!!: " +
+ DataApi::developer_error("Must open table before adding an list!!: " +
list_name + " += " + next_elem);
return false;
}
{
if (open_tables.size() == 0)
{
- data_api.developer_error("Must open table before adding comment !!: '" +
+ DataApi::developer_error("Must open table before adding comment !!: '" +
comment + "'");
- data_api.developer_error("comment added to as a general lua comment");
- data_api.add_comment(comment);
+ DataApi::developer_error("comment added to as a general lua comment");
+// data_api.add_comment(comment);
return false;
}
{
if (open_tables.size() == 0)
{
- data_api.developer_error("Must open table before calling option_exists() !!");
+ DataApi::developer_error("Must open table before calling option_exists() !!");
return false;
}
if (open_tables.size() == 0)
{
- data_api.developer_error("Must open table before adding an option!!: " +
+ DataApi::developer_error("Must open table before adding an option!!: " +
orig_var + " = " + new_var);
return false;
}
if (open_tables.size() == 0)
{
- data_api.developer_error("Must open a table before adding "
+ DataApi::developer_error("Must open a table before adding "
"deprecated comment!!: " + dep_var);
return false;
}
if (open_tables.size() == 0)
{
- data_api.developer_error("Must open a tablebefore adding an "
+ DataApi::developer_error("Must open a tablebefore adding an "
"'unsupported' comment");
return false;
}
* creating new convesion states. There are comments in
* in all caps which show the seperate the sections.
*
-* The first section of this file is really LuaData creation
+* The first section of this file is really DataApi creation
* and initialization, and adding miscelaneous objects
-* to the LuaData data. The second section is for creating
+* to the DataApi data. The second section is for creating
* tables and their options. The third section is for
* creating rules.
*/
class Table;
class TableApi;
-extern TableApi table_api;
class TableApi
{
#include "data/dt_data.h"
-InitState::InitState() : ConversionState() {}
+InitState::InitState(Converter& c) : ConversionState(c) {}
bool InitState::convert(std::istringstream& data_stream)
{
const ConvertMap *map = util::find_map(keywords::keywords_api, keyword);
if (map)
{
- cv.set_state(map->ctor());
+ cv.set_state(map->ctor(cv));
return true;
}
class InitState : public ConversionState
{
public:
- InitState();
+ InitState(Converter&);
virtual ~InitState() {};
virtual bool convert(std::istringstream& data);
};
-static inline ConversionState* init_state_ctor()
+static inline ConversionState* init_state_ctor(Converter& c)
{
- return new InitState();
+ return new InitState(c);
}
#endif
class AttributeTable : public ConversionState
{
public:
- AttributeTable() : ConversionState() {};
+ AttributeTable(Converter& c) : ConversionState(c) {};
virtual ~AttributeTable() {};
virtual bool convert(std::istringstream& data);
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new AttributeTable();
-}
+static ConversionState* ctor(Converter& c)
+{ return new AttributeTable(c); }
static const ConvertMap attribute_table_api =
{
class Config : public ConversionState
{
public:
- Config() : ConversionState() {};
+ Config(Converter& c) : ConversionState(c) {};
virtual ~Config() {};
virtual bool convert(std::istringstream& data);
};
const ConvertMap* map = util::find_map(config::config_api, keyword);
if (map)
{
- cv.set_state(map->ctor());
+ cv.set_state(map->ctor(cv));
return true;
}
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new Config();
-}
+static ConversionState* ctor(Converter& c)
+{ return new Config(c); }
static const ConvertMap keyword_config =
{
class EventFilter : public ConversionState
{
public:
- EventFilter() : ConversionState() {};
+ EventFilter(Converter& c) : ConversionState(c) {};
virtual ~EventFilter() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new EventFilter();
-}
+static ConversionState* ctor(Converter& c)
+{ return new EventFilter(c); }
static const ConvertMap event_filter_api =
{
class File : public ConversionState
{
public:
- File() : ConversionState() {};
+ File(Converter& c) : ConversionState(c) {};
virtual ~File() {};
virtual bool convert(std::istringstream& data);
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new File();
-}
+static ConversionState* ctor(Converter& c)
+{ return new File(c); }
static const ConvertMap keyword_file =
{
class Include : public ConversionState
{
public:
- Include() : ConversionState() {};
+ Include(Converter& c) : ConversionState(c) {};
virtual ~Include() {};
virtual bool convert(std::istringstream& data);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new Include();
-}
+static ConversionState* ctor(Converter& c)
+{ return new Include(c); }
static const ConvertMap keyword_include =
{
class Output : public ConversionState
{
public:
- Output() : ConversionState() {};
+ Output(Converter& c) : ConversionState(c) {};
virtual ~Output() {};
virtual bool convert(std::istringstream& data);
};
const ConvertMap* map = util::find_map(output::output_api, keyword);
if (map)
{
- cv.set_state(map->ctor());
+ cv.set_state(map->ctor(cv));
return true;
}
}
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new Output();
-}
+static ConversionState* ctor(Converter& c)
+{ return new Output(c); }
static const ConvertMap keyword_output =
{
class Paths : public ConversionState
{
public:
- Paths() : ConversionState() {};
+ Paths(Converter& c) : ConversionState(c) {};
virtual ~Paths() {};
virtual bool convert(std::istringstream& data_stream)
template<const std::string *snort_option>
-static ConversionState* paths_ctor()
-{
- return new Paths<snort_option>();
-}
+static ConversionState* paths_ctor(Converter& c)
+{ return new Paths<snort_option>(c); }
} // namespace
class Preprocessor : public ConversionState
{
public:
- Preprocessor() : ConversionState() {};
+ Preprocessor(Converter& c) : ConversionState(c) {};
virtual ~Preprocessor() {};
virtual bool convert(std::istringstream& data);
};
const ConvertMap* map = util::find_map(preprocessors::preprocessor_api, keyword);
if (map)
{
- cv.set_state(map->ctor());
+ cv.set_state(map->ctor(cv));
return true;
}
data_api.failed_conversion(data_stream, keyword);
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new Preprocessor();
-}
+static ConversionState* ctor(Converter& c)
+{ return new Preprocessor(c); }
static const ConvertMap keyword_preprocessor =
{
class RateFilter : public ConversionState
{
public:
- RateFilter() : ConversionState() {};
+ RateFilter(Converter& c) : ConversionState(c) {};
virtual ~RateFilter() {};
virtual bool convert(std::istringstream& data);
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new RateFilter();
-}
+static ConversionState* ctor(Converter& c)
+{ return new RateFilter(c); }
static const ConvertMap keyword_rate_filter =
{
class RuleHeader : public ConversionState
{
public:
- explicit RuleHeader() : ConversionState() {};
+ explicit RuleHeader(Converter& c) : ConversionState(c) {};
virtual ~RuleHeader() {};
virtual bool convert(std::istringstream& data_stream);
};
********************************/
template<const std::string *name>
-static ConversionState* rule_ctor()
+static ConversionState* rule_ctor(Converter& c)
{
- rule_api.add_hdr_data(*name);
- return new RuleHeader();
+ c.get_rule_api().add_hdr_data(*name);
+ return new RuleHeader(c);
}
template<const std::string *name>
-static ConversionState* dep_rule_ctor()
+static ConversionState* dep_rule_ctor(Converter& c)
{
- rule_api.add_hdr_data(*name);
- rule_api.make_rule_a_comment();
- rule_api.add_comment_to_rule("The '" + *name + "' ruletype is no longer supported");
- return new RuleHeader();
+ c.get_rule_api().add_hdr_data(*name);
+ c.get_rule_api().make_rule_a_comment();
+ c.get_rule_api().add_comment_to_rule("The '" + *name + "' ruletype is no longer supported");
+ return new RuleHeader(c);
}
static const std::string alert = "alert";
class RuleState : public ConversionState
{
public:
- RuleState() : ConversionState() {};
+ RuleState(Converter& c) : ConversionState(c) {};
virtual ~RuleState() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new RuleState();
-}
+static ConversionState* ctor(Converter& c)
+{ return new RuleState(c); }
static const ConvertMap rule_state_api =
{
class RuleType : public ConversionState
{
public:
- RuleType() : ConversionState() {};
+ RuleType(Converter& c) : ConversionState(c) {};
virtual ~RuleType() {};
virtual bool convert(std::istringstream& data);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new RuleType();
-}
+static ConversionState* ctor(Converter& c)
+{ return new RuleType(); }
static const ConvertMap keyword_ruletype =
{
class Suppress : public ConversionState
{
public:
- Suppress() : ConversionState() {};
+ Suppress(Converter& c) : ConversionState(c) {};
virtual ~Suppress() {};
virtual bool convert(std::istringstream& data);
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new Suppress();
-}
+static ConversionState* ctor(Converter& c)
+{ return new Suppress(c); }
static const ConvertMap keyword_supress =
{
class Var : public ConversionState
{
public:
- Var() : ConversionState(){}
+ Var(Converter& c) : ConversionState(c){}
virtual ~Var() {};
virtual bool convert(std::istringstream& data);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
-{
- return new Var();
-}
+static ConversionState* ctor(Converter& c)
+{ return new Var(c); }
static const ConvertMap keyword_portvar =
{
class AlertCsv : public ConversionState
{
public:
- AlertCsv() : ConversionState() {};
+ AlertCsv(Converter& c) : ConversionState(c) {};
virtual ~AlertCsv() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_top_level_table("alert_csv"); // in case there are no arguments
- table_api.close_table();
- return new AlertCsv();
+ c.get_table_api().open_top_level_table("alert_csv"); // in case there are no arguments
+ c.get_table_api().close_table();
+ return new AlertCsv(c);
}
static const ConvertMap alert_csv_api =
class AlertFast : public ConversionState
{
public:
- AlertFast() : ConversionState() {};
+ AlertFast(Converter& c) : ConversionState(c) {};
virtual ~AlertFast() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_top_level_table("alert_fast"); // in case there are no arguments
- table_api.close_table();
- return new AlertFast();
+ c.get_table_api().open_top_level_table("alert_fast"); // in case there are no arguments
+ c.get_table_api().close_table();
+ return new AlertFast(c);
}
static const ConvertMap alert_fast_api =
class AlertFull : public ConversionState
{
public:
- AlertFull() : ConversionState() {};
+ AlertFull(Converter& c) : ConversionState(c) {};
virtual ~AlertFull() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_top_level_table("alert_full"); // in case there are no arguments
- table_api.close_table();
- return new AlertFull();
+ c.get_table_api().open_top_level_table("alert_full"); // in case there are no arguments
+ c.get_table_api().close_table();
+ return new AlertFull(c);
}
static const ConvertMap alert_full_api =
namespace output
{
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_table("alert_null"); // in case there are no arguments
- table_api.close_table();
+ c.get_table_api().open_table("alert_null");
+ c.get_table_api().close_table();
return nullptr;
}
class AlertSyslog : public ConversionState
{
public:
- AlertSyslog() : ConversionState() {};
+ AlertSyslog(Converter& c) : ConversionState(c) {};
virtual ~AlertSyslog() {};
virtual bool convert(std::istringstream& data_stream);
};
}
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_top_level_table("alert_syslog"); // in case there are no arguments
- table_api.close_table();
- return new AlertSyslog();
+ c.get_table_api().open_top_level_table("alert_syslog"); // in case there are no arguments
+ c.get_table_api().close_table();
+ return new AlertSyslog(c);
}
class LogTcpDump : public ConversionState
{
public:
- LogTcpDump() : ConversionState() {};
+ LogTcpDump(Converter& c) : ConversionState(c) {};
virtual ~LogTcpDump() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_top_level_table("log_tcpdump"); // in case there are no arguments
- table_api.close_table();
- return new LogTcpDump();
+ c.get_table_api().open_top_level_table("log_tcpdump"); // in case there are no arguments
+ c.get_table_api().close_table();
+ return new LogTcpDump(c);
}
static const ConvertMap log_tcpdump_api =
class AlertTest : public ConversionState
{
public:
- AlertTest() : ConversionState() {};
+ AlertTest(Converter& c) : ConversionState(c) {};
virtual ~AlertTest() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_top_level_table("alert_test"); // in case there are no arguments
- table_api.close_table();
- return new AlertTest();
+ c.get_table_api().open_top_level_table("alert_test"); // in case there are no arguments
+ c.get_table_api().close_table();
+ return new AlertTest(c);
}
static const ConvertMap alert_test_api =
class Unified2 : public ConversionState
{
public:
- Unified2() : ConversionState() {};
+ Unified2(Converter& c) : ConversionState(c) {};
virtual ~Unified2() {};
virtual bool convert(std::istringstream& data_stream)
};
template<const std::string* output_name>
-static ConversionState* unified2_ctor()
+static ConversionState* unified2_ctor(Converter& c)
{
- table_api.open_top_level_table("unified2"); // create table in case there are no arguments
- table_api.close_table();
- return new Unified2<output_name>();
+ c.get_table_api().open_top_level_table("unified2"); // create table in case there are no arguments
+ c.get_table_api().close_table();
+ return new Unified2<output_name>(c);
}
} // namespace
namespace output
{
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- table_api.open_table("alert_unixsock"); // in case there are no arguments
- table_api.close_table();
+ c.get_table_api().open_table("alert_unixsock");
+ c.get_table_api().close_table();
return nullptr;
}
class ArpSpoof : public ConversionState
{
public:
- ArpSpoof() : ConversionState() {};
+ ArpSpoof(Converter& c) : ConversionState(c) {};
virtual ~ArpSpoof() {};
virtual bool convert(std::istringstream& data_stream);
};
/******* A P I ***********/
-static ConversionState* arpspoof_ctor()
+static ConversionState* arpspoof_ctor(Converter& c)
{
- return new ArpSpoof();
+ return new ArpSpoof(c);
}
static const ConvertMap preprocessor_arpspoof =
class ArpSpoofHost : public ConversionState
{
public:
- ArpSpoofHost() : ConversionState() {};
+ ArpSpoofHost(Converter& c) : ConversionState(c) {};
virtual ~ArpSpoofHost() {};
virtual bool convert(std::istringstream& data_stream);
};
/******* A P I ***********/
-static ConversionState* arpspoof_host_ctor()
+static ConversionState* arpspoof_host_ctor(Converter& c)
{
- return new ArpSpoofHost();
+ return new ArpSpoofHost(c);
}
static const ConvertMap preprocessor_arpspoof_host =
namespace preprocessors
{
-static ConversionState* bo_ctor()
+static ConversionState* bo_ctor(Converter& c)
{
- table_api.open_table("bo");
- table_api.close_table();
+ c.get_table_api().open_table("bo");
+ c.get_table_api().close_table();
return nullptr;
}
class Frag3Engine : public ConversionState
{
public:
- explicit Frag3Engine() : ConversionState() {};
+ explicit Frag3Engine(Converter& c) : ConversionState(c) {};
virtual ~Frag3Engine() {};
virtual bool convert(std::istringstream& data_stream);
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Frag3Engine();
+ return new Frag3Engine(c);
}
static const ConvertMap preprocessor_frag3_engine =
class Frag3Global : public ConversionState
{
public:
- Frag3Global() : ConversionState() {};
+ Frag3Global(Converter& c) : ConversionState(c) {};
virtual ~Frag3Global() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Frag3Global();
+ return new Frag3Global(c);
}
static const ConvertMap preprocessor_frag3_global =
class FtpTelnet : public ConversionState
{
public:
- FtpTelnet() : ConversionState() {};
+ FtpTelnet(Converter& c) : ConversionState(c) {};
virtual ~FtpTelnet() {};
virtual bool convert(std::istringstream& data_stream);
private:
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new FtpTelnet();
+ return new FtpTelnet(c);
}
static const ConvertMap preprocessor_ftptelnet =
class FtpServer : public ConversionState
{
public:
- FtpServer();
- virtual ~FtpServer() {};
+ FtpServer(Converter& c) : ConversionState(c) { }
+ virtual ~FtpServer() { }
virtual bool convert(std::istringstream& data_stream);
private:
struct Command
int FtpServer::ftpsever_binding_id = 1;
-FtpServer::FtpServer() : ConversionState()
-{}
-
std::vector<FtpServer::Command>::iterator FtpServer::get_command(
std::string cmd_name,
std::vector<FtpServer::Command>::iterator it)
{
std::string keyword;
bool retval = true;
- Binder bind;
+ Binder bind(table_api);
bind.set_use_type("ftp_server");
bind.set_when_proto("tcp");
class FtpClient : public ConversionState
{
public:
- FtpClient() : ConversionState() {};
+ FtpClient(Converter& c) : ConversionState(c) {};
virtual ~FtpClient() {};
virtual bool convert(std::istringstream& data_stream);
private:
{
std::string keyword;
bool retval = true;
- Binder bind;
+ Binder bind(table_api);
bind.set_use_type("ftp_client");
bind.set_when_proto("tcp");
class Telnet : public ConversionState
{
public:
- Telnet() : ConversionState() {};
+ Telnet(Converter& c) : ConversionState(c) {};
virtual ~Telnet() {};
virtual bool convert(std::istringstream& data_stream);
};
std::string keyword;
int i_val;
bool retval = true;
- Binder bind;
+ Binder bind(table_api);
bind.set_when_proto("tcp");
bind.set_use_type("telnet");
class FtpTelnetProtocol : public ConversionState
{
public:
- FtpTelnetProtocol() : ConversionState() {};
+ FtpTelnetProtocol(Converter& c) : ConversionState(c) {};
virtual ~FtpTelnetProtocol() {};
virtual bool convert(std::istringstream& data_stream);
};
{
if(!protocol.compare("telnet"))
{
- cv.set_state(new Telnet());
+ cv.set_state(new Telnet(cv));
}
else if (!protocol.compare("ftp"))
{
if(data_stream >> protocol)
{
if(!protocol.compare("client"))
- cv.set_state(new FtpClient());
+ cv.set_state(new FtpClient(cv));
else if (!protocol.compare("server"))
- cv.set_state(new FtpServer());
+ cv.set_state(new FtpServer(cv));
else
return false;
/******* PUBLIC API ************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new FtpTelnetProtocol();
+ return new FtpTelnetProtocol(c);
}
static const ConvertMap ftptelnet_protocol_preprocessor =
class Gtp : public ConversionState
{
public:
- Gtp() : ConversionState() {};
+ Gtp(Converter& c) : ConversionState(c) {};
virtual ~Gtp() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Gtp();
+ return new Gtp(c);
}
static const ConvertMap preprocessor_gtp =
class HttpInspect : public ConversionState
{
public:
- HttpInspect();
- virtual ~HttpInspect() {};
+ HttpInspect(Converter& c) : ConversionState(c) { }
+ virtual ~HttpInspect() {}
virtual bool convert(std::istringstream& data);
private:
} // namespace
-
-HttpInspect::HttpInspect() : ConversionState()
-{}
-
bool HttpInspect::convert(std::istringstream& data_stream)
{
std::string keyword;
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new HttpInspect();
+ return new HttpInspect(c);
}
static const ConvertMap preprocessor_httpinspect =
class HttpInspectServer : public ConversionState
{
public:
- HttpInspectServer() : ConversionState() {};
+ HttpInspectServer(Converter& c) : ConversionState(c) {};
virtual ~HttpInspectServer() {};
virtual bool convert(std::istringstream& data_stream);
{
std::string keyword;
bool retval = true;
- Binder bind;
+ Binder bind(table_api);
bind.set_when_proto("tcp");
bind.set_use_type("http_server");
return retval;
}
-#if 0
-// check in confg
-
-
-#* decompress_swf { deflate lzma } *
-#* decompress_pdf { deflate } *
-
-#endif
/**************************
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new HttpInspectServer();
+ return new HttpInspectServer(c);
}
static const ConvertMap preprocessor_httpinsepct_server =
template<const std::string *norm_option>
-static ConversionState* norm_sans_options_ctor()
+static ConversionState* norm_sans_options_ctor(Converter& c)
{
- table_api.open_table("normalize");
- table_api.add_diff_option_comment("preprocessor normalize_" + *norm_option, *norm_option + " = <bool>");
- table_api.add_option(*norm_option, true);
- table_api.close_table();
+ c.get_table_api().open_table("normalize");
+ c.get_table_api().add_diff_option_comment("preprocessor normalize_" + *norm_option, *norm_option + " = <bool>");
+ c.get_table_api().add_option(*norm_option, true);
+ c.get_table_api().close_table();
return nullptr;
}
class Ip4Normalizer : public ConversionState
{
public:
- Ip4Normalizer() : ConversionState() {};
+ Ip4Normalizer(Converter& c) : ConversionState(c) {};
virtual ~Ip4Normalizer() {};
virtual bool convert(std::istringstream& data_stream);
};
/******* A P I ***********/
-static ConversionState* ip4_ctor()
+static ConversionState* ip4_ctor(Converter& c)
{
- return new Ip4Normalizer();
+ return new Ip4Normalizer(c);
}
static const ConvertMap preprocessor_norm_ip4 =
class TcpNormalizer : public ConversionState
{
public:
- TcpNormalizer() : ConversionState() {};
+ TcpNormalizer(Converter& c) : ConversionState(c) {};
virtual ~TcpNormalizer() {};
virtual bool convert(std::istringstream& data_stream);
};
/******* A P I ***********/
-static ConversionState* tcp_ctor()
+static ConversionState* tcp_ctor(Converter& c)
{
- return new TcpNormalizer();
+ return new TcpNormalizer(c);
}
static const ConvertMap preprocessor_norm_tcp =
class PerfMonitor : public ConversionState
{
public:
- PerfMonitor() : ConversionState() {};
+ PerfMonitor(Converter& c) : ConversionState(c) {};
virtual ~PerfMonitor() {};
virtual bool convert(std::istringstream& data_stream);
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new PerfMonitor();
+ return new PerfMonitor(c);
}
static const ConvertMap keyword_perfmonitor =
class RpcDecode : public ConversionState
{
public:
- RpcDecode() : ConversionState() {};
+ RpcDecode(Converter& c) : ConversionState(c) {};
virtual ~RpcDecode() {};
virtual bool convert(std::istringstream& data_stream);
};
std::string keyword;
// adding the binder entry
- Binder bind;
+ Binder bind(table_api);
bind.set_when_proto("tcp");
bind.set_use_type("rpc_decode");
std::string port_list = std::string();
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new RpcDecode();
+ return new RpcDecode(c);
}
static const ConvertMap preprocessor_rpc_decode =
class PortScan : public ConversionState
{
public:
- PortScan() : ConversionState() {};
+ PortScan(Converter& c) : ConversionState(c) {};
virtual ~PortScan() {};
virtual bool convert(std::istringstream& data_stream);
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new PortScan();
+ return new PortScan(c);
}
static const ConvertMap preprocessor_sfportscan =
class StreamGlobal : public ConversionState
{
public:
- StreamGlobal() : ConversionState() {};
+ StreamGlobal(Converter& c) : ConversionState(c) {};
virtual ~StreamGlobal() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new StreamGlobal();
+ return new StreamGlobal(c);
}
static const ConvertMap preprocessor_stream_global =
class StreamIp : public ConversionState
{
public:
- StreamIp() : ConversionState() {};
+ StreamIp(Converter& c) : ConversionState(c) {};
virtual ~StreamIp() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new StreamIp();
+ return new StreamIp(c);
}
static const ConvertMap preprocessor_stream_ip =
class StreamTcp : public ConversionState
{
public:
- StreamTcp();
+ StreamTcp(Converter&);
virtual ~StreamTcp() {};
virtual bool convert(std::istringstream& data_stream);
} // namespace
-StreamTcp::StreamTcp() : ConversionState()
+StreamTcp::StreamTcp(Converter& c) : ConversionState(c)
{
bind_client = nullptr;
bind_server = nullptr;
std::string keyword;
bool retval = true;
- Binder client;
- Binder server;
- Binder any;
+ Binder client(table_api);
+ Binder server(table_api);
+ Binder any(table_api);
// by default, only print one binding
client.print_binding(true);
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new StreamTcp();
+ return new StreamTcp(c);
}
static const ConvertMap preprocessor_stream_tcp =
class StreamUdp : public ConversionState
{
public:
- StreamUdp() : ConversionState() {};
+ StreamUdp(Converter& c) : ConversionState(c) {};
virtual ~StreamUdp() {};
virtual bool convert(std::istringstream& data_stream);
};
******* A P I ***********
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new StreamUdp();
+ return new StreamUdp(c);
}
static const ConvertMap preprocessor_stream_udp =
class Base64Decode : public ConversionState
{
public:
- Base64Decode() : ConversionState() {};
+ Base64Decode(Converter& c) : ConversionState(c) {};
virtual ~Base64Decode() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& cv)
{
- return new Base64Decode();
+ return new Base64Decode(cv);
}
static const std::string base64_decode = "base64_decode";
class Content : public ConversionState
{
public:
- Content() : ConversionState() {};
+ Content(Converter& c) : ConversionState(c) {};
virtual ~Content() {};
virtual bool convert(std::istringstream& data);
};
template<const std::string *rule_name>
-static ConversionState* content_ctor()
+static ConversionState* content_ctor(Converter& c)
{
- return new Content<rule_name>();
+ return new Content<rule_name>(c);
}
static const std::string content = "content";
// Uricontent:"foo" --> http_uti; content:"foo".
// So, just add the 'http_uri' option first, then parse as if content
-static ConversionState* uricontent_ctor()
+static ConversionState* uricontent_ctor(Converter& c)
{
- rule_api.add_rule_option("http_uri");
- rule_api.add_comment_to_rule("uricontent deprecated --> 'http_uri: content:'foo'");
- return new Content<&content>();
+ c.get_rule_api().add_rule_option("http_uri");
+ c.get_rule_api().add_comment_to_rule("uricontent deprecated --> 'http_uri: content:'foo'");
+ return new Content<&content>(c);
}
class FileData : public ConversionState
{
public:
- FileData() : ConversionState() {};
+ FileData(Converter& c) : ConversionState(c) {};
virtual ~FileData() {};
virtual bool convert(std::istringstream& data);
};
******* A P I ***********
**************************/
-static ConversionState* file_data_ctor()
+static ConversionState* file_data_ctor(Converter& c)
{
- return new FileData();
+ return new FileData(c);
}
static const ConvertMap rule_file_data =
class HttpEncode : public ConversionState
{
public:
- HttpEncode() : ConversionState() {};
+ HttpEncode(Converter& c) : ConversionState(c) {};
virtual ~HttpEncode() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new HttpEncode();
+ return new HttpEncode(c);
}
static const std::string http_encode = "http_encode";
class Metadata : public ConversionState
{
public:
- Metadata() : ConversionState() {};
+ Metadata(Converter& c) : ConversionState(c) {};
virtual ~Metadata() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Metadata();
+ return new Metadata(c);
}
static const std::string metadata = "metadata";
class Pcre : public ConversionState
{
public:
- Pcre() : ConversionState() {};
+ Pcre(Converter& c) : ConversionState(c) {};
virtual ~Pcre() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Pcre();
+ return new Pcre(c);
}
class React : public ConversionState
{
public:
- React() : ConversionState() {};
+ React(Converter& c) : ConversionState(c) {};
virtual ~React() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
-{ return new React(); }
+static ConversionState* ctor(Converter& c)
+{ return new React(c); }
static const ConvertMap rule_react =
{
class Resp : public ConversionState
{
public:
- Resp() : ConversionState() {};
+ Resp(Converter& c) : ConversionState(c) {};
virtual ~Resp() {};
virtual bool convert(std::istringstream& data);
private:
**************************/
-static ConversionState* ctor()
-{ return new Resp(); }
+static ConversionState* ctor(Converter& c)
+{ return new Resp(c); }
static const ConvertMap rule_resp =
{
class Threshold : public ConversionState
{
public:
- Threshold() : ConversionState() {};
+ Threshold(Converter& c) : ConversionState(c) {};
virtual ~Threshold() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Threshold();
+ return new Threshold(c);
}
static const ConvertMap rule_threshold =
class UnchangedRuleOption : public ConversionState
{
public:
- UnchangedRuleOption() : ConversionState() {};
+ UnchangedRuleOption(Converter& c) : ConversionState(c) {};
virtual ~UnchangedRuleOption() {};
virtual bool convert(std::istringstream& stream)
template<const std::string *rule_name, bool has_suboptions = true>
-static ConversionState* unchanged_rule_ctor()
+static ConversionState* unchanged_rule_ctor(Converter& c)
{
- return new UnchangedRuleOption<rule_name, has_suboptions>();
+ return new UnchangedRuleOption<rule_name, has_suboptions>(c);
}
/****************************************
class Urilen : public ConversionState
{
public:
- Urilen() : ConversionState() {};
+ Urilen(Converter& c) : ConversionState(c) {};
virtual ~Urilen() {};
virtual bool convert(std::istringstream& data);
};
**************************/
-static ConversionState* ctor()
+static ConversionState* ctor(Converter& c)
{
- return new Urilen();
+ return new Urilen(c);
}
static const std::string urilen = "urilen";
static void print_line(std::string s)
{
- if (!data_api.is_quiet_mode())
+ if (!DataApi::is_quiet_mode())
std::cout << s << std::endl;
}
}
// MAIN CONVERSION FUNCTION!!
- cv.initialize(&init_state_ctor);
- if (cv.convert_file(conf_file) < 0)
+ Converter cv;
+ if (cv.convert(conf_file, output_file, rule_file, error_file) < 0)
{
print_line("Failed Conversion of file " + conf_file);
fail = true;
}
- // keep track whether we're printing rules into a seperate file.
- bool rule_file_specifed = false;
-
- if (!rule_api.empty())
- {
- if (!rule_file.compare(output_file))
- {
- std::string s = std::string("$default_rules");
- rule_file_specifed = false;
-
- table_api.open_top_level_table("ips");
- table_api.add_option("rules", s);
- table_api.close_table();
- }
- else
- {
- rule_file_specifed = true;
-
- table_api.open_top_level_table("ips");
- table_api.add_option("include", rule_file);
- table_api.close_table();
- }
- }
-
-
- // Snort++ requires a binder table to be instantiated,
- // although not necessarily filled. So, just add this table.
- // If its already added, these lines won't have any effect
- table_api.open_top_level_table("binder");
- table_api.close_table();
-
- // finally, lets print the converter to file
- std::ofstream out;
- out.open(output_file, std::ifstream::out);
- out << "require(\"snort_config\") -- for loading\n\n";
-
- if (!rule_file_specifed)
- {
- data_api.print_data(out);
- rule_api.print_rules(out, rule_file_specifed);
- table_api.print_tables(out);
- data_api.print_comments(out);
-
-
- out << std::endl;
-
- if ((data_api.failed_conversions() || rule_api.failed_conversions()) &&
- !data_api.is_quiet_mode())
- {
- std::ofstream rejects; // in this case, rejects are regular configuration options
- rejects.open(error_file, std::ifstream::out);
-
- if (data_api.failed_conversions())
- data_api.print_errors(rejects);
-
- if (rule_api.failed_conversions())
- rule_api.print_rejects(rejects);
-
- rejects << std::endl;
- rejects.close();
- }
- }
- else
- {
- std::ofstream rules;
- rules.open(rule_file, std::ifstream::out);
-
- data_api.print_data(out);
- rule_api.print_rules(rules, rule_file_specifed);
- table_api.print_tables(out);
- data_api.print_comments(out);
-
- // flush all data
- out << std::endl;
- rules << std::endl;
- rules.close();
-
- if ((data_api.failed_conversions() || rule_api.failed_conversions()) &&
- !data_api.is_quiet_mode())
- {
- std::ofstream rejects; // in this case, rejects are regular configuration options
- rejects.open(error_file, std::ifstream::out);
-
- if (data_api.failed_conversions())
- data_api.print_errors(rejects);
-
- if (rule_api.failed_conversions())
- rule_api.print_rejects(rejects);
-
- rejects << std::endl;
- rejects.close();
- }
- }
-
-
- out.close();
-
- if (fail || data_api.failed_conversions() || rule_api.failed_conversions())
+ if (fail || cv.failed_conversions())
return -2;
return 0;
}
#include "conversion_state.h"
#include "data/data_types/dt_comment.h"
#include "utils/s2l_util.h"
+#include "init_state.h"
+
+
+
+bool Converter::parse_includes = true;
+bool Converter::convert_rules_mult_files = true;
+bool Converter::convert_conf_mult_files = true;
-Converter cv;
Converter::Converter()
: state(nullptr),
- init_state_ctor(nullptr),
- parse_includes(true),
- convert_rules_mult_files(true),
- convert_conf_mult_files(true),
error(false)
{
}
delete state;
}
-bool Converter::initialize(conv_new_f func)
-{
- init_state_ctor = func;
- state = init_state_ctor();
-
- if (state == nullptr)
- {
- data_api.developer_error("Failed Converter initialization!");
- return false;
- }
-
- return true;
-}
-
void Converter::set_state(ConversionState* c)
{
delete state;
if (state)
delete state;
- state = init_state_ctor();
+ state = new InitState(*this);
data_api.reset_state();
table_api.reset_state();
rule_api.reset_state();
- if (convert_file(input_file) < 0)
+ if (parse_file(input_file) < 0)
error = true; // return a negative number to main snort2lua method
}
}
-int Converter::convert_file(std::string input_file)
+int Converter::parse_file(std::string input_file)
{
std::ifstream in;
std::string orig_text;
// this is set by parse_include_file
return error ? -3 : 0;
}
+
+bool Converter::initialize()
+{
+ state = new InitState(*this);
+
+ if (state == nullptr)
+ {
+ DataApi::developer_error("Failed Converter initialization!");
+ return false;
+ }
+
+ return true;
+}
+
+int Converter::convert(std::string input,
+ std::string output_file,
+ std::string rule_file,
+ std::string error_file)
+{
+ int rc;
+ initialize();
+
+ rc = parse_file(input);
+
+ if (rc < 0)
+ return rc;
+
+
+ // keep track whether we're printing rules into a seperate file.
+ bool rule_file_specifed = false;
+
+
+ if (!rule_api.empty())
+ {
+ std::cout << "rule_file" << rule_file << std::endl;
+ std::cout << "out_file " << output_file << std::endl;
+ if (rule_file.empty() || !rule_file.compare(output_file))
+ {
+ std::string s = std::string("$default_rules");
+ rule_file_specifed = false;
+
+ table_api.open_top_level_table("ips");
+ table_api.add_option("rules", s);
+ table_api.close_table();
+ }
+ else
+ {
+ rule_file_specifed = true;
+
+ table_api.open_top_level_table("ips");
+ table_api.add_option("include", rule_file);
+ table_api.close_table();
+ }
+ }
+
+
+ // Snort++ requires a binder table to be instantiated,
+ // although not necessarily filled. So, just add this table.
+ // If its already added, these lines won't have any effect
+ table_api.open_top_level_table("binder");
+ table_api.close_table();
+
+ // finally, lets print the converter to file
+ std::ofstream out;
+ out.open(output_file, std::ifstream::out);
+
+ out << "require(\"snort_config\") -- for loading\n\n";
+ data_api.print_data(out);
+
+
+ if (!rule_file_specifed)
+ {
+ rule_api.print_rules(out, rule_file_specifed);
+ }
+ else
+ {
+ std::ofstream rules;
+ rules.open(rule_file, std::ifstream::out);
+ rule_api.print_rules(rules, rule_file_specifed);
+ rules.close();
+ }
+
+
+ table_api.print_tables(out);
+ data_api.print_comments(out);
+
+
+
+ if ((failed_conversions()) && !DataApi::is_quiet_mode())
+ {
+ if (error_file.empty())
+ {
+ if (data_api.failed_conversions())
+ data_api.print_errors(out);
+
+ if (rule_api.failed_conversions())
+ rule_api.print_rejects(out);
+ }
+ else
+ {
+ std::ofstream rejects; // in this case, rejects are regular configuration options
+ rejects.open(error_file, std::ifstream::out);
+
+ if (data_api.failed_conversions())
+ data_api.print_errors(rejects);
+
+ if (rule_api.failed_conversions())
+ rule_api.print_rejects(rejects);
+
+ rejects.close();
+ }
+ }
+
+
+ out.close();
+ return rc;
+}
/*
** Copyright (C) 2014 Cisco and/or its affiliates. All rights reserved.
- * Copyright (C) 2002-2013 Sourcefire, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License Version 2 as
- * published by the Free Software Foundation. You may not use, modify or
- * distribute this program under any other version of the GNU General
- * Public License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License Version 2 as
+** published by the Free Software Foundation. You may not use, modify or
+** distribute this program under any other version of the GNU General
+** Public License.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
// converter.h author Josh Rosenbaum <jrosenba@cisco.com>
#ifndef UTILS_CONVERTER_H
#include <string>
#include "conversion_defines.h"
-
-class Converter;
-extern Converter cv;
+#include "data/dt_data.h"
+#include "data/dt_table_api.h"
+#include "data/dt_rule_api.h"
class Converter
{
public:
Converter();
virtual ~Converter();
- // initialize data class
- bool initialize(conv_new_f init_state_func);
- // set the next parsing state.
- void set_state(ConversionState* c);
+
+
// tells this class whether to parse include files.
- inline void set_parse_includes(bool val) { parse_includes = val; }
+ inline static void set_parse_includes(bool val)
+ { parse_includes = val; }
// tells this class whether to convert a file inline or pull all data into one file.
- inline void create_mult_rule_files(bool var) { convert_rules_mult_files = var; }
+ inline static void create_mult_rule_files(bool var)
+ { convert_rules_mult_files = var; }
// tells this class whether to convert a file inline or pull all data into one file.
- inline void create_mult_conf_files(bool var) { convert_conf_mult_files = var; }
+ inline static void create_mult_conf_files(bool var)
+ { convert_conf_mult_files = var; }
+
+
+ int convert(std::string input,
+ std::string output,
+ std::string rules = "", // defaults to output_file
+ std::string errors = ""); // defaults to output_file
+
+
+ // set the next parsing state.
+ void set_state(ConversionState* c);
// reset the current parsing state
void reset_state();
- // convert the following file from a snort.conf into a lua.conf
- int convert_file(std::string input_file);
// parse an include file. Use this function to ensure all set options are properly
void parse_include_file(std::string file);
+
+ bool failed_conversions() const
+ { return data_api.failed_conversions() || rule_api.failed_conversions(); }
+
+
// Should we parse an include file?
- inline bool should_convert_includes() { return parse_includes; }
+ inline bool should_convert_includes() const
+ { return parse_includes; }
+
+ inline DataApi& get_data_api()
+ { return data_api; }
+
+ inline TableApi& get_table_api()
+ { return table_api; }
+
+ inline RuleApi& get_rule_api()
+ { return rule_api; }
+
private:
+ static bool parse_includes;
+ static bool convert_rules_mult_files;
+ static bool convert_conf_mult_files;
+
+ DataApi data_api;
+ TableApi table_api;
+ RuleApi rule_api;
+
// the current parsing state.
ConversionState* state;
- // the data which will be printed into the new lua file
- // the init_state constructor
- conv_new_f init_state_ctor;
-
- bool parse_includes;
- bool convert_rules_mult_files;
- bool convert_conf_mult_files;
bool error;
+
+ // convert the following file from a snort.conf into a lua.conf
+ int parse_file(std::string input_file);
+ // initialize data class
+ bool initialize();
};
{ return rule_file.empty() ? get_out_file() : rule_file; }
static void help_args(const char* pfx);
+static void help_usage();
//-------------------------------------------------------------------------
}
static void print_all(const char* /*key*/, const char* /*val*/)
-{ data_api.set_default_print(); }
+{ DataApi::set_default_print(); }
static void print_quiet(const char* /*key*/, const char* /*val*/)
-{ data_api.set_quiet_print(); }
+{ DataApi::set_quiet_print(); }
static void print_differences(const char* /*key*/, const char* /*val*/)
-{ data_api.set_difference_print(); }
+{ DataApi::set_difference_print(); }
static void sing_rule_files(const char* /*key*/, const char* /*val*/)
-{ cv.create_mult_rule_files(false); }
+{ Converter::create_mult_rule_files(false); }
static void sing_conf_files(const char* /*key*/, const char* /*val*/)
-{ cv.create_mult_conf_files(false); }
+{ Converter::create_mult_conf_files(false); }
static void dont_parse_includes(const char* /*key*/, const char* /*val*/)
-{ cv.set_parse_includes(false); }
+{ Converter::set_parse_includes(false); }
typedef void (*ParseConfigFunc)(const char*, const char* val);
{ nullptr, nullptr, nullptr }
};
+#if 0
+FIXIT-H J delete!!
+SnortConfig* parse_cmd_line(int argc, char* argv[])
+{
+ ArgList al(argc, argv);
+ const char* key, *val;
+ unsigned c = 0;
+
+ // get special options first
+ while ( al.get_arg(key, val) )
+ {
+ ::set(key, val, sc, false);
+ c++;
+ }
+
+ // now get the rest
+ al.reset();
+
+ while ( al.get_arg(key, val) )
+ {
+ ::set(key, val, sc, true);
+ c++;
+ }
+
+ if ( !c )
+ help_usage(sc, argv[0]);
+ else
+ check_flags(sc);
+
+ if ( int k = get_parse_errors() )
+ FatalError("see prior %d errors\n", k);
+
+ return sc;
+}
+#endif
+
bool parse_cmd_line(int argc, char* argv[])
{
ArgList al(argc, argv);
const char *key, *val;
+ bool found_opt = false;
while ( al.get_arg(key, val) )
{
{
p->parse_func(key, val);
}
+
+ found_opt = true;
}
+ if (!found_opt)
+ help_usage();
+
+
return true;
}
+static void help_usage()
+{
+ fprintf(stdout, "usage:\n");
+ fprintf(stdout, " -?: list options\n");
+ fprintf(stdout, " -V: output version\n");
+ fprintf(stdout, " --help: help summary\n");
+ exit(1);
+}
+
static void help_args(const char* pfx)
{
} // namespace parser
#endif
-
#include "data/dt_table_api.h"
-Binder::Binder() : printed(false), when_policy_id(-1) {}
+Binder::Binder(TableApi& t) : table_api(t),
+ printed(false),
+ when_policy_id(-1)
+{ }
Binder::~Binder()
{
#include <string>
#include <vector>
+class TableApi;
// If the user never adds add_to_configuration,
// the destructor will call the method
class Binder
{
public:
- Binder();
+ Binder(TableApi&);
~Binder();
void add_to_configuration();
private:
+ TableApi& table_api;
bool printed; // ensures that the binding is added once,
// by either the destructor or user
projects / thirdparty / snort3.git / commitdiff
