busy.emplace_back(idle.back());
idle.pop_back();
- busy.back()->packet->active = busy.back()->packet->active_inst;
- busy.back()->packet->active->reset();
+ IpsContext* c = busy.back();
+ c->packet->active = c->packet->active_inst;
+ c->packet->active->reset();
+ c->packet->action = &c->packet->action_inst;
}
void ContextSwitcher::stop()
c->clear_context_data();
idle.emplace_back(c);
busy.back()->packet->active = nullptr;
+ busy.back()->packet->action = nullptr;
busy.pop_back();
}
Packet* DetectionEngine::set_next_packet(Packet* parent)
{
static THREAD_LOCAL Active shutdown_active;
+ static THREAD_LOCAL IpsAction* shutdown_action = nullptr;
IpsContext* c = Snort::get_switcher()->get_next();
if ( parent )
// normal rebuild
if ( parent )
+ {
p->active = parent->active;
+ p->action = parent->action;
+ }
// processing but parent is already gone (flow cache flush etc..)
else if ( Snort::get_switcher()->get_context() )
+ {
p->active = get_current_packet()->active;
+ p->action = get_current_packet()->action;
+ }
// shutdown, so use a dummy so null checking is not needed everywhere
else
{
+ p->action = &shutdown_action;
p->active = &shutdown_active;
shutdown_active.reset();
}
// rule actions are queued here (eg reject)
if ( rtn->listhead->action )
- ActionManager::queue(rtn->listhead->action);
+ ActionManager::queue(rtn->listhead->action, p);
}
/*
DetectionEngine::reset();
sfthreshold_reset();
- ActionManager::reset_queue();
+ ActionManager::reset_queue(s_packet);
DAQ_Verdict verdict = process_packet(s_packet, pkthdr, pkt);
ActionManager::execute(s_packet);
IpsAction* reject = nullptr;
};
-typedef vector<ActionClass> ACList;
+using ACList = vector<ActionClass>;
static ACList s_actors;
static THREAD_LOCAL ACList* s_tl_actors = nullptr;
-static THREAD_LOCAL IpsAction* s_tl_action = nullptr;
//-------------------------------------------------------------------------
// Main thread operations
void ActionManager::execute(Packet* p)
{
- if ( s_tl_action )
+ if ( *p->action )
{
- s_tl_action->exec(p);
- s_tl_action = nullptr;
+ (*p->action)->exec(p);
+ *p->action = nullptr;
}
}
-void ActionManager::queue(IpsAction* a)
+void ActionManager::queue(IpsAction* a, Packet* p)
{
- if ( !s_tl_action || a->get_action() > s_tl_action->get_action() )
- s_tl_action = a;
+ if ( !(*p->action) || a->get_action() > (*p->action)->get_action() )
+ *p->action = a;
}
-void ActionManager::queue_reject(SnortConfig* sc)
+void ActionManager::queue_reject(SnortConfig* sc, Packet* p)
{
if ( sc->ips_actions_config->reject )
- queue(sc->ips_actions_config->reject);
+ queue(sc->ips_actions_config->reject, p);
}
-void ActionManager::reset_queue()
+void ActionManager::reset_queue(Packet* p)
{
- s_tl_action = nullptr;
+ *p->action = nullptr;
Replace_ResetQueue();
}
static void thread_reinit(snort::SnortConfig*);
static void thread_term(snort::SnortConfig*);
- static void reset_queue();
- static void queue_reject(snort::SnortConfig*);
- static void queue(snort::IpsAction*);
+ static void reset_queue(snort::Packet*);
+ static void queue_reject(snort::SnortConfig*, snort::Packet*);
+ static void queue(snort::IpsAction*, snort::Packet*);
static void execute(snort::Packet*);
#ifdef PIGLET
if ( enabled )
{
- ActionManager::queue_reject(SnortConfig::get_conf());
+ ActionManager::queue_reject(SnortConfig::get_conf(), p);
if ( p->flow )
{
class Active;
class Endianness;
class Flow;
+class IpsAction;
class IpsContext;
class Obfuscator;
IpsContext* context; // set by control
Active* active;
Active* active_inst;
+ IpsAction** action;
+ IpsAction* action_inst;
const DAQ_PktHdr_t* pkth; // packet meta data
const uint8_t* pkt; // raw packet data