diff --git a/src/Plugin.cc b/src/Plugin.cc index ccf6e24..576484f 100644 --- a/src/Plugin.cc +++ b/src/Plugin.cc @@ -7,12 +7,12 @@ namespace plugin { namespace Johanna_PostgreSQL { Plugin plugin; } } using namespace plugin::Johanna_PostgreSQL; -plugin::Configuration Plugin::Configure() +zeek::plugin::Configuration Plugin::Configure() { - AddComponent(new ::logging::Component("PostgreSQL", ::logging::writer::PostgreSQL::Instantiate)); - AddComponent(new ::input::Component("PostgreSQL", ::input::reader::PostgreSQL::Instantiate)); + AddComponent(new zeek::logging::Component("PostgreSQL", ::logging::writer::PostgreSQL::Instantiate)); + AddComponent(new zeek::input::Component("PostgreSQL", ::input::reader::PostgreSQL::Instantiate)); - plugin::Configuration config; + zeek::plugin::Configuration config; config.name = "Johanna::PostgreSQL"; config.description = "PostgreSQL log writer and input reader"; config.version.major = 0; diff --git a/src/Plugin.h b/src/Plugin.h index 7144044..bf54eb3 100644 --- a/src/Plugin.h +++ b/src/Plugin.h @@ -7,15 +7,14 @@ namespace plugin { namespace Johanna_PostgreSQL { -class Plugin : public ::plugin::Plugin +class Plugin : public zeek::plugin::Plugin { protected: // Overridden from plugin::Plugin. - virtual plugin::Configuration Configure(); + virtual zeek::plugin::Configuration Configure(); }; extern Plugin plugin; - } } diff --git a/src/PostgresReader.cc b/src/PostgresReader.cc index 1213c7b..1a48b44 100644 --- a/src/PostgresReader.cc +++ b/src/PostgresReader.cc @@ -13,13 +13,13 @@ #include "PostgresReader.h" using namespace input::reader; -using threading::Value; -using threading::Field; +using zeek::threading::Value; +using zeek::threading::Field; -PostgreSQL::PostgreSQL(ReaderFrontend *frontend) : ReaderBackend(frontend) +PostgreSQL::PostgreSQL(zeek::input::ReaderFrontend *frontend) : zeek::input::ReaderBackend(frontend) { - io = std::unique_ptr(new threading::formatter::Ascii(this, threading::formatter::Ascii::SeparatorInfo())); + io = std::unique_ptr(new zeek::threading::formatter::Ascii(this, zeek::threading::formatter::Ascii::SeparatorInfo())); } PostgreSQL::~PostgreSQL() @@ -42,7 +42,7 @@ std::string PostgreSQL::LookupParam(const ReaderInfo& info, const std::string na return it->second; } -bool PostgreSQL::DoInit(const ReaderInfo& info, int arg_num_fields, const threading::Field* const* arg_fields) +bool PostgreSQL::DoInit(const ReaderInfo& info, int arg_num_fields, const zeek::threading::Field* const* arg_fields) { assert(arg_fields); assert(arg_num_fields >= 0); @@ -104,18 +104,18 @@ std::string PostgreSQL::EscapeIdentifier(const char* identifier) return out; } -std::unique_ptr PostgreSQL::EntryToVal(std::string s, const threading::Field* field) +std::unique_ptr PostgreSQL::EntryToVal(std::string s, const zeek::threading::Field* field) { std::unique_ptr val(new Value(field->type, true)); switch ( field->type ) { - case TYPE_ENUM: - case TYPE_STRING: + case zeek::TYPE_ENUM: + case zeek::TYPE_STRING: val->val.string_val.length = s.size(); - val->val.string_val.data = copy_string(s.c_str()); + val->val.string_val.data = zeek::util::copy_string(s.c_str()); break; - case TYPE_BOOL: + case zeek::TYPE_BOOL: if ( s == "t" ) { val->val.int_val = 1; } else if ( s == "f" ) { @@ -126,27 +126,26 @@ std::unique_ptr PostgreSQL::EntryToVal(std::string s, const threading::Fi } break; - case TYPE_INT: + case zeek::TYPE_INT: val->val.int_val = atoi(s.c_str()); break; - case TYPE_DOUBLE: - case TYPE_TIME: - case TYPE_INTERVAL: + case zeek::TYPE_DOUBLE: + case zeek::TYPE_TIME: + case zeek::TYPE_INTERVAL: val->val.double_val = atof(s.c_str()); break; - case TYPE_COUNT: - case TYPE_COUNTER: + case zeek::TYPE_COUNT: val->val.uint_val = atoi(s.c_str()); break; - case TYPE_PORT: + case zeek::TYPE_PORT: val->val.port_val.port = atoi(s.c_str()); val->val.port_val.proto = TRANSPORT_UNKNOWN; break; - case TYPE_SUBNET: { + case zeek::TYPE_SUBNET: { int pos = s.find("/"); int width = atoi(s.substr(pos+1).c_str()); std::string addr = s.substr(0, pos); @@ -156,12 +155,12 @@ std::unique_ptr PostgreSQL::EntryToVal(std::string s, const threading::Fi break; } - case TYPE_ADDR: + case zeek::TYPE_ADDR: val->val.addr_val = io->ParseAddr(s); break; - case TYPE_TABLE: - case TYPE_VECTOR: + case zeek::TYPE_TABLE: + case zeek::TYPE_VECTOR: // First - common stuff // Then - initialization for table. // Then - initialization for vector. @@ -241,12 +240,12 @@ std::unique_ptr PostgreSQL::EntryToVal(std::string s, const threading::Fi for ( decltype(vals.size()) i = 0; itype == TYPE_TABLE ) + if ( field->type == zeek::TYPE_TABLE ) { val->val.set_val.vals = lvals; val->val.set_val.size = vals.size(); } - else if ( field->type == TYPE_VECTOR ) + else if ( field->type == zeek::TYPE_VECTOR ) { val->val.vector_val.vals = lvals; val->val.vector_val.size = vals.size(); diff --git a/src/PostgresReader.h b/src/PostgresReader.h index c40a617..267ba4a 100644 --- a/src/PostgresReader.h +++ b/src/PostgresReader.h @@ -13,9 +13,9 @@ namespace input { namespace reader { -class PostgreSQL : public ReaderBackend { +class PostgreSQL : public zeek::input::ReaderBackend { public: - explicit PostgreSQL(ReaderFrontend* frontend); + explicit PostgreSQL(zeek::input::ReaderFrontend* frontend); ~PostgreSQL(); // prohibit copying and moving @@ -23,10 +23,10 @@ class PostgreSQL : public ReaderBackend { PostgreSQL& operator=(const PostgreSQL&) = delete; PostgreSQL(PostgreSQL&&) = delete; - static ReaderBackend* Instantiate(ReaderFrontend* frontend) { return new PostgreSQL(frontend); } + static zeek::input::ReaderBackend* Instantiate(zeek::input::ReaderFrontend* frontend) { return new PostgreSQL(frontend); } protected: - bool DoInit(const ReaderInfo& info, int arg_num_fields, const threading::Field* const* fields) override; + bool DoInit(const ReaderInfo& info, int arg_num_fields, const zeek::threading::Field* const* fields) override; void DoClose() override; @@ -38,12 +38,12 @@ class PostgreSQL : public ReaderBackend { // note - EscapeIdentifier is replicated in writier std::string EscapeIdentifier(const char* identifier); std::string LookupParam(const ReaderInfo& info, const std::string name) const; - std::unique_ptr EntryToVal(std::string s, const threading::Field* type); + std::unique_ptr EntryToVal(std::string s, const zeek::threading::Field* type); PGconn *conn; - std::unique_ptr io; + std::unique_ptr io; - const threading::Field* const * fields; // raw mapping + const zeek::threading::Field* const * fields; // raw mapping std::string query; int num_fields; }; diff --git a/src/PostgresWriter.cc b/src/PostgresWriter.cc index cfd0e7e..f9a81df 100644 --- a/src/PostgresWriter.cc +++ b/src/PostgresWriter.cc @@ -15,24 +15,24 @@ using namespace logging; using namespace writer; -using threading::Value; -using threading::Field; +using zeek::threading::Value; +using zeek::threading::Field; -PostgreSQL::PostgreSQL(WriterFrontend* frontend) : WriterBackend(frontend) +PostgreSQL::PostgreSQL(zeek::logging::WriterFrontend* frontend) : zeek::logging::WriterBackend(frontend) { - io = std::unique_ptr(new threading::formatter::Ascii(this, threading::formatter::Ascii::SeparatorInfo())); + io = std::unique_ptr(new zeek::threading::formatter::Ascii(this, zeek::threading::formatter::Ascii::SeparatorInfo())); default_hostname.assign( - (const char*) BifConst::LogPostgres::default_hostname->Bytes(), - BifConst::LogPostgres::default_hostname->Len() + (const char*) zeek::BifConst::LogPostgres::default_hostname->Bytes(), + zeek::BifConst::LogPostgres::default_hostname->Len() ); default_dbname.assign( - (const char*) BifConst::LogPostgres::default_dbname->Bytes(), - BifConst::LogPostgres::default_dbname->Len() + (const char*) zeek::BifConst::LogPostgres::default_dbname->Bytes(), + zeek::BifConst::LogPostgres::default_dbname->Len() ); - default_port = BifConst::LogPostgres::default_port; + default_port = zeek::BifConst::LogPostgres::default_port; ignore_errors = false; bytea_instead_text = false; @@ -49,47 +49,46 @@ std::string PostgreSQL::GetTableType(int arg_type, int arg_subtype) std::string type; switch ( arg_type ) { - case TYPE_BOOL: + case zeek::TYPE_BOOL: type = "boolean"; break; - case TYPE_INT: - case TYPE_COUNT: - case TYPE_COUNTER: - case TYPE_PORT: + case zeek::TYPE_INT: + case zeek::TYPE_COUNT: + case zeek::TYPE_PORT: type = "bigint"; break; /* - case TYPE_PORT: + case zeek::TYPE_PORT: type = "VARCHAR(10)"; break; */ - case TYPE_SUBNET: - case TYPE_ADDR: + case zeek::TYPE_SUBNET: + case zeek::TYPE_ADDR: type = "inet"; break; - case TYPE_TIME: - case TYPE_INTERVAL: - case TYPE_DOUBLE: + case zeek::TYPE_TIME: + case zeek::TYPE_INTERVAL: + case zeek::TYPE_DOUBLE: type = "double precision"; break; - case TYPE_ENUM: + case zeek::TYPE_ENUM: type = "TEXT"; break; - case TYPE_STRING: - case TYPE_FILE: - case TYPE_FUNC: + case zeek::TYPE_STRING: + case zeek::TYPE_FILE: + case zeek::TYPE_FUNC: type = "TEXT"; if ( bytea_instead_text ) type = "BYTEA"; break; - case TYPE_TABLE: - case TYPE_VECTOR: + case zeek::TYPE_TABLE: + case zeek::TYPE_VECTOR: type = GetTableType(arg_subtype, 0) + "[]"; break; @@ -273,46 +272,45 @@ std::tuple PostgreSQL::CreateParams(const Value* val) switch ( val->type ) { - case TYPE_BOOL: + case zeek::TYPE_BOOL: retval = val->val.int_val ? "T" : "F"; break; - case TYPE_INT: + case zeek::TYPE_INT: retval = std::to_string(val->val.int_val); break; - case TYPE_COUNT: - case TYPE_COUNTER: + case zeek::TYPE_COUNT: retval = std::to_string(val->val.uint_val); break; - case TYPE_PORT: + case zeek::TYPE_PORT: retval = std::to_string(val->val.port_val.port); break; - case TYPE_SUBNET: + case zeek::TYPE_SUBNET: retval = io->Render(val->val.subnet_val); break; - case TYPE_ADDR: + case zeek::TYPE_ADDR: retval = io->Render(val->val.addr_val); break; - case TYPE_TIME: - case TYPE_INTERVAL: - case TYPE_DOUBLE: + case zeek::TYPE_TIME: + case zeek::TYPE_INTERVAL: + case zeek::TYPE_DOUBLE: retval = std::to_string(val->val.double_val); break; - case TYPE_ENUM: - case TYPE_STRING: - case TYPE_FILE: - case TYPE_FUNC: + case zeek::TYPE_ENUM: + case zeek::TYPE_STRING: + case zeek::TYPE_FILE: + case zeek::TYPE_FUNC: retval = std::string(val->val.string_val.data, val->val.string_val.length); break; - case TYPE_TABLE: - case TYPE_VECTOR: + case zeek::TYPE_TABLE: + case zeek::TYPE_VECTOR: { bro_int_t size; Value** vals; @@ -320,7 +318,7 @@ std::tuple PostgreSQL::CreateParams(const Value* val) std::string out("{"); retlength = 1; - if ( val->type == TYPE_TABLE ) + if ( val->type == zeek::TYPE_TABLE ) { size = val->val.set_val.size; vals = val->val.set_val.vals; @@ -347,11 +345,11 @@ std::tuple PostgreSQL::CreateParams(const Value* val) } std::string resstr = std::get<1>(res); - TypeTag type = vals[i]->type; + zeek::TypeTag type = vals[i]->type; // for all numeric types, we do not need escaping - if ( type == TYPE_BOOL || type == TYPE_INT || type == TYPE_COUNT || - type == TYPE_COUNTER || type == TYPE_PORT || type == TYPE_TIME || - type == TYPE_INTERVAL || type == TYPE_DOUBLE ) + if ( type == zeek::TYPE_BOOL || type == zeek::TYPE_INT || type == zeek::TYPE_COUNT || + type == zeek::TYPE_PORT || type == zeek::TYPE_TIME || + type == zeek::TYPE_INTERVAL || type == zeek::TYPE_DOUBLE ) out += resstr; else { diff --git a/src/PostgresWriter.h b/src/PostgresWriter.h index dfa84f0..9185d4f 100644 --- a/src/PostgresWriter.h +++ b/src/PostgresWriter.h @@ -13,9 +13,9 @@ namespace logging { namespace writer { -class PostgreSQL : public WriterBackend { +class PostgreSQL : public zeek::logging::WriterBackend { public: - PostgreSQL(WriterFrontend* frontend); + PostgreSQL(zeek::logging::WriterFrontend* frontend); ~PostgreSQL(); // prohibit copying and moving @@ -23,12 +23,12 @@ class PostgreSQL : public WriterBackend { PostgreSQL& operator=(const PostgreSQL&) = delete; PostgreSQL(PostgreSQL&&) = delete; - static WriterBackend* Instantiate(WriterFrontend* frontend) + static zeek::logging::WriterBackend* Instantiate(zeek::logging::WriterFrontend* frontend) { return new PostgreSQL(frontend); } protected: - bool DoInit(const WriterInfo& info, int num_fields, const threading::Field* const* fields) override; - bool DoWrite(int num_fields, const threading::Field* const* fields, threading::Value** vals) override; + bool DoInit(const WriterInfo& info, int num_fields, const zeek::threading::Field* const* fields) override; + bool DoWrite(int num_fields, const zeek::threading::Field* const* fields, zeek::threading::Value** vals) override; bool DoSetBuf(bool enabled) override; bool DoRotate(const char* rotated_path, double open, double close, bool terminating) override; bool DoFlush(double network_time) override; @@ -39,9 +39,9 @@ class PostgreSQL : public WriterBackend { std::string LookupParam(const WriterInfo& info, const std::string name) const; // note - EscapeIdentifier is replicated in reader std::string EscapeIdentifier(const char* identifier); - std::tuple CreateParams(const threading::Value* val); + std::tuple CreateParams(const zeek::threading::Value* val); std::string GetTableType(int, int); - bool CreateInsert(int num_fields, const threading::Field* const* fields, const std::string add_string = ""); + bool CreateInsert(int num_fields, const zeek::threading::Field* const* fields, const std::string add_string = ""); PGconn *conn; @@ -55,7 +55,7 @@ class PostgreSQL : public WriterBackend { bool ignore_errors; bool bytea_instead_text; - std::unique_ptr io; + std::unique_ptr io; }; }