#include "main/analyzer.h"
#include "main/analyzer_command.h"
-class ACShellCmd : public AnalyzerCommand
+class ACShellCmd : public snort::AnalyzerCommand
{
public:
ACShellCmd() = delete;
- ACShellCmd(int fd, AnalyzerCommand* ac_cmd);
+ ACShellCmd(int fd, snort::AnalyzerCommand* ac_cmd);
void execute(Analyzer&) override;
const char* stringify() override { return ac->stringify(); }
~ACShellCmd() override;
private:
int control_fd = -1;
- AnalyzerCommand* ac;
+ snort::AnalyzerCommand* ac;
};
#endif
#include "thread.h"
-class AnalyzerCommand;
class ContextSwitcher;
class OopsHandler;
class RetryQueue;
namespace snort
{
+class AnalyzerCommand;
class SFDAQInstance;
struct Packet;
struct SnortConfig;
void set_pause_after_cnt(uint64_t msg_cnt) { pause_after_cnt = msg_cnt; }
void set_skip_cnt(uint64_t msg_cnt) { skip_cnt = msg_cnt; }
- void execute(AnalyzerCommand*);
+ void execute(snort::AnalyzerCommand*);
void post_process_packet(snort::Packet*);
bool process_rebuilt_packet(snort::Packet*, const DAQ_PktHdr_t*, const uint8_t* pkt, uint32_t pktlen);
void reload_daq();
void reinit(snort::SnortConfig*);
void rotate();
+ snort::SFDAQInstance* get_daq_instance() { return daq_instance; }
private:
void analyze();
void init_unprivileged();
void term();
void show_source();
- void cache_analyzer_command(AnalyzerCommand* aci) { ac = aci; }
- void add_command_to_completed_queue(AnalyzerCommand *ac);
- AnalyzerCommand* get_analyzer_command() { return ac; }
+ void cache_analyzer_command(snort::AnalyzerCommand* aci) { ac = aci; }
+ void add_command_to_completed_queue(snort::AnalyzerCommand *ac);
+ snort::AnalyzerCommand* get_analyzer_command() { return ac; }
public:
- std::queue<AnalyzerCommand*> completed_work_queue;
+ std::queue<snort::AnalyzerCommand*> completed_work_queue;
std::mutex completed_work_queue_mutex;
- std::queue<AnalyzerCommand*> pending_work_queue;
+ std::queue<snort::AnalyzerCommand*> pending_work_queue;
private:
std::atomic<State> state;
RetryQueue* retry_queue = nullptr;
OopsHandler* oops_handler = nullptr;
ContextSwitcher* switcher = nullptr;
- AnalyzerCommand* ac = nullptr;
+ snort::AnalyzerCommand* ac = nullptr;
std::mutex pending_work_queue_mutex;
};
snort::LogMessage("== daq module reload complete\n");
}
+snort::SFDAQInstance* snort::AnalyzerCommand::get_daq_instance(Analyzer& analyzer)
+{
+ return analyzer.get_daq_instance();
+}
class Request;
class Swapper;
+namespace snort
+{
+class SFDAQInstance;
+
class AnalyzerCommand
{
public:
unsigned put() { return --ref_count; }
bool is_complete() { return completion_status; }
void set_completion_status(bool status) { completion_status = status; }
+ SO_PUBLIC static snort::SFDAQInstance* get_daq_instance(Analyzer& analyzer);
private:
unsigned ref_count = 0;
bool completion_status = true;
};
+}
-class ACGetStats : public AnalyzerCommand
+class ACGetStats : public snort::AnalyzerCommand
{
public:
void execute(Analyzer&) override;
~ACGetStats() override;
};
-class ACPause : public AnalyzerCommand
+class ACPause : public snort::AnalyzerCommand
{
public:
void execute(Analyzer&) override;
const char* stringify() override { return "PAUSE"; }
};
-class ACResume : public AnalyzerCommand
+class ACResume : public snort::AnalyzerCommand
{
public:
ACResume(uint64_t msg_cnt): msg_cnt(msg_cnt) { }
uint64_t msg_cnt;
};
-class ACRotate : public AnalyzerCommand
+class ACRotate : public snort::AnalyzerCommand
{
public:
void execute(Analyzer&) override;
const char* stringify() override { return "ROTATE"; }
};
-class ACRun : public AnalyzerCommand
+class ACRun : public snort::AnalyzerCommand
{
public:
ACRun() = delete;
bool paused = false;
};
-class ACStart : public AnalyzerCommand
+class ACStart : public snort::AnalyzerCommand
{
public:
void execute(Analyzer&) override;
const char* stringify() override { return "START"; }
};
-class ACStop : public AnalyzerCommand
+class ACStop : public snort::AnalyzerCommand
{
public:
void execute(Analyzer&) override;
const char* stringify() override { return "STOP"; }
};
-class ACSwap : public AnalyzerCommand
+class ACSwap : public snort::AnalyzerCommand
{
public:
ACSwap() = delete;
bool from_shell;
};
-class ACDAQSwap : public AnalyzerCommand
+class ACDAQSwap : public snort::AnalyzerCommand
{
public:
void execute(Analyzer&) override;
namespace snort
{
// from main.cc
-SO_PUBLIC void main_broadcast_command(AnalyzerCommand* ac, bool from_shell = false);
+SO_PUBLIC void main_broadcast_command(snort::AnalyzerCommand* ac, bool from_shell = false);
}
#endif