139 lines
4.0 KiB
C++
139 lines
4.0 KiB
C++
#include "snote_thread.hpp"
|
|
|
|
#include "irc_parse_thread.hpp"
|
|
#include "connection.hpp"
|
|
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
#include <stdexcept>
|
|
#include <utility>
|
|
#include <regex>
|
|
|
|
namespace {
|
|
|
|
struct SnotePattern
|
|
{
|
|
SnotePattern(SnoteTag tag, char const* expression, unsigned flags = 0)
|
|
: tag{tag}
|
|
, expression{expression}
|
|
, flags{flags}
|
|
, regex{expression, std::regex_constants::ECMAScript | std::regex_constants::optimize}
|
|
{
|
|
}
|
|
|
|
SnoteTag tag;
|
|
char const* expression;
|
|
unsigned flags;
|
|
std::regex regex;
|
|
};
|
|
|
|
SnotePattern const patterns[] =
|
|
{
|
|
{SnoteTag::ClientConnecting,
|
|
R"(^Client connecting: ([^ ]+) \(([^@ ]+)@([^) ]+)\) \[(.*)\] \{([^ ]*)\} <([^ ]*)> \[(.*)\]$)"},
|
|
|
|
{SnoteTag::ClientExiting,
|
|
R"(^Client exiting: ([^ ]+) \(([^@ ]+)@([^) ]+)\) \[(.*)\] \[(.*)\]$)"},
|
|
};
|
|
|
|
auto setup_database() -> std::unique_ptr<hs_database_t, SnoteThread::DbDeleter>
|
|
{
|
|
std::vector<char const*> expressions;
|
|
std::vector<unsigned> flags;
|
|
std::vector<unsigned> ids;
|
|
|
|
expressions.reserve(std::size(patterns));
|
|
flags.reserve(std::size(patterns));
|
|
ids.reserve(std::size(patterns));
|
|
|
|
unsigned id = 0;
|
|
|
|
for (auto const& pattern : patterns)
|
|
{
|
|
expressions.push_back(pattern.expression);
|
|
flags.push_back(pattern.flags);
|
|
ids.push_back(id++);
|
|
}
|
|
|
|
hs_database_t* db;
|
|
hs_compile_error *error;
|
|
|
|
switch (hs_compile_multi(expressions.data(), flags.data(), ids.data(), expressions.size(), HS_MODE_BLOCK, nullptr, &db, &error))
|
|
{
|
|
case HS_COMPILER_ERROR:
|
|
{
|
|
std::string msg = error->message;
|
|
hs_free_compile_error(error);
|
|
throw std::runtime_error{std::move(msg)};
|
|
}
|
|
case HS_SUCCESS:
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
return std::unique_ptr<hs_database_t, SnoteThread::DbDeleter>{db};
|
|
}
|
|
|
|
} // namespace
|
|
|
|
auto SnoteThread::start(Connection& connection) -> std::shared_ptr<SnoteThread>
|
|
{
|
|
auto thread = std::make_shared<SnoteThread>();
|
|
|
|
thread->db_ = setup_database();
|
|
|
|
hs_scratch_t* scratch = nullptr;
|
|
if (HS_SUCCESS != hs_alloc_scratch(thread->db_.get(), &scratch))
|
|
{
|
|
abort();
|
|
}
|
|
thread->scratch_ = std::unique_ptr<hs_scratch_t, ScratchDeleter>{scratch};
|
|
|
|
static char const* const prefix = "*** Notice -- ";
|
|
connection.add_listener<IrcMsgEvent>([&connection, thread](IrcMsgEvent& event)
|
|
{
|
|
auto& args = event.irc.args;
|
|
if (IrcCommand::NOTICE == event.command
|
|
&& "*" == args[0]
|
|
&& args[1].starts_with(prefix))
|
|
{
|
|
event.handled_ = true;
|
|
auto message = args[1].substr(strlen(prefix));
|
|
unsigned int match_id = -1;
|
|
auto const scan_result = hs_scan(thread->db_.get(), message.data(), message.size(), 0, thread->scratch_.get(),
|
|
[](unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *context) -> int
|
|
{
|
|
int* const match_id = static_cast<int*>(context);
|
|
*match_id = id;
|
|
return 1; // stop scanning
|
|
}
|
|
, &match_id);
|
|
|
|
if (scan_result != HS_SUCCESS && scan_result != HS_SCAN_TERMINATED)
|
|
{
|
|
abort();
|
|
}
|
|
|
|
if (match_id != -1)
|
|
{
|
|
auto& pattern = patterns[match_id];
|
|
std::match_results<std::string_view::const_iterator> results;
|
|
if (not std::regex_match(message.begin(), message.end(), results, pattern.regex))
|
|
{
|
|
// something went wrong - hyperscan disagrees with std::regex
|
|
abort();
|
|
}
|
|
|
|
std::vector<std::string_view> parts;
|
|
for (auto const sub : results)
|
|
{
|
|
parts.push_back(std::string_view{sub.first, sub.second});
|
|
}
|
|
connection.make_event<SnoteEvent>(pattern.tag, std::move(parts));
|
|
}
|
|
}
|
|
});
|
|
|
|
return thread;
|
|
}
|