end:
/* Process all statfiles */
process_statfiles (task);
+ /* Call post filters */
+ lua_call_post_filters (task);
+ task->state = WRITE_REPLY;
/* XXX: ugly direct call */
if (task->fin_callback) {
task->fin_callback (task->fin_arg);
else if (!task->pass_all_filters &&
metric->action == METRIC_ACTION_REJECT &&
check_metric_is_spam (task, metric)) {
+ task->state = WRITE_REPLY;
return 1;
}
cur = g_list_next (cur);
g_hash_table_foreach (task->results, composites_metric_callback, task);
}
-
-struct statfile_callback_data {
- GHashTable *tokens;
- struct worker_task *task;
-};
-
static void
classifiers_callback (gpointer value, void *arg)
{
- struct statfile_callback_data *data = (struct statfile_callback_data *)arg;
- struct worker_task *task = data->task;
+ struct worker_task *task = arg;
struct classifier_config *cl = value;
struct classifier_ctx *ctx;
struct mime_text_part *text_part;
}
ctx = cl->classifier->init_func (task->task_pool, cl);
- if ((tokens = g_hash_table_lookup (data->tokens, cl->tokenizer)) == NULL) {
+ if ((tokens = g_hash_table_lookup (task->tokens, cl->tokenizer)) == NULL) {
while (cur != NULL) {
if (header) {
c.len = strlen (cur->data);
}
cur = g_list_next (cur);
}
- g_hash_table_insert (data->tokens, cl->tokenizer, tokens);
+ g_hash_table_insert (task->tokens, cl->tokenizer, tokens);
}
if (tokens == NULL) {
void
process_statfiles (struct worker_task *task)
{
- struct statfile_callback_data cd;
-
+
if (task->is_skipped) {
return;
}
- cd.task = task;
- cd.tokens = g_hash_table_new (g_direct_hash, g_direct_equal);
- g_list_foreach (task->cfg->classifiers, classifiers_callback, &cd);
- g_hash_table_destroy (cd.tokens);
+ if (task->tokens == NULL) {
+ task->tokens = g_hash_table_new (g_direct_hash, g_direct_equal);
+ memory_pool_add_destructor (task->task_pool, (pool_destruct_func)g_hash_table_destroy, task->tokens);
+ }
+
+ g_list_foreach (task->cfg->classifiers, classifiers_callback, task);
/* Process results */
make_composites (task);
- task->state = WRITE_REPLY;
}
static void
LUA_FUNCTION_DEF (config, add_hash_map);
LUA_FUNCTION_DEF (config, get_classifier);
LUA_FUNCTION_DEF (config, register_symbol);
+LUA_FUNCTION_DEF (config, register_post_filter);
static const struct luaL_reg configlib_m[] = {
LUA_INTERFACE_DEF (config, get_module_opt),
LUA_INTERFACE_DEF (config, add_hash_map),
LUA_INTERFACE_DEF (config, get_classifier),
LUA_INTERFACE_DEF (config, register_symbol),
+ LUA_INTERFACE_DEF (config, register_post_filter),
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
register_expression_function (name, lua_config_function_callback, cd);
}
}
- return 0;
+ return 1;
+}
+
+void
+lua_call_post_filters (struct worker_task *task)
+{
+ struct lua_callback_data *cd;
+ struct worker_task **ptask;
+ GList *cur;
+
+ cur = task->cfg->post_filters;
+ while (cur) {
+ cd = cur->data;
+ lua_getglobal (cd->L, cd->name);
+ ptask = lua_newuserdata (cd->L, sizeof (struct worker_task *));
+ lua_setclass (cd->L, "rspamd{task}", -1);
+ *ptask = task;
+
+ if (lua_pcall (cd->L, 1, 1, 0) != 0) {
+ msg_warn ("error running function %s: %s", cd->name, lua_tostring (cd->L, -1));
+ }
+ cur = g_list_next (cur);
+ }
+}
+
+static int
+lua_config_register_post_filter (lua_State *L)
+{
+ struct config_file *cfg = lua_check_config (L);
+ const char *callback;
+ struct lua_callback_data *cd;
+
+ if (cfg) {
+
+ callback = luaL_checkstring (L, 2);
+ if (callback) {
+ cd = g_malloc (sizeof (struct lua_callback_data));
+ cd->name = g_strdup (callback);
+ cd->L = L;
+ cfg->post_filters = g_list_prepend (cfg->post_filters, cd);
+ }
+ }
+ return 1;
}
static int
#include "lua_common.h"
#include "../message.h"
#include "../expressions.h"
+#include "../protocol.h"
+#include "../filter.h"
#include "../dns.h"
+#include "../util.h"
#include "../images.h"
+#include "../cfg_file.h"
+#include "../statfile.h"
+#include "../tokenizers/tokenizers.h"
+#include "../classifiers/classifiers.h"
+#include "../binlog.h"
+#include "../statfile_sync.h"
+
+extern stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct classifier_config *ccf,
+ const char *symbol, struct statfile **st, gboolean try_create);
/* Task methods */
LUA_FUNCTION_DEF (task, get_message);
LUA_FUNCTION_DEF (task, get_client_ip_num);
LUA_FUNCTION_DEF (task, get_helo);
LUA_FUNCTION_DEF (task, get_images);
+LUA_FUNCTION_DEF (task, get_symbol);
+LUA_FUNCTION_DEF (task, get_metric_score);
+LUA_FUNCTION_DEF (task, get_metric_action);
+LUA_FUNCTION_DEF (task, learn_statfile);
static const struct luaL_reg tasklib_m[] = {
LUA_INTERFACE_DEF (task, get_message),
LUA_INTERFACE_DEF (task, get_client_ip_num),
LUA_INTERFACE_DEF (task, get_helo),
LUA_INTERFACE_DEF (task, get_images),
+ LUA_INTERFACE_DEF (task, get_symbol),
+ LUA_INTERFACE_DEF (task, get_metric_score),
+ LUA_INTERFACE_DEF (task, get_metric_action),
+ LUA_INTERFACE_DEF (task, learn_statfile),
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
return 1;
}
+G_INLINE_FUNC gboolean
+lua_push_symbol_result (lua_State *L, struct worker_task *task, struct metric *metric, const char *symbol)
+{
+ struct metric_result *metric_res;
+ struct symbol *s;
+ int j;
+ GList *opt;
+
+ metric_res = g_hash_table_lookup (task->results, metric->name);
+ if (metric_res) {
+ if ((s = g_hash_table_lookup (metric_res->symbols, symbol)) != NULL) {
+ j = 0;
+ lua_newtable (L);
+ lua_pushstring (L, "metric");
+ lua_pushstring (L, metric->name);
+ lua_settable (L, -3);
+ lua_pushstring (L, "score");
+ lua_pushnumber (L, s->score);
+ lua_settable (L, -3);
+ if (s->options) {
+ opt = s->options;
+ lua_pushstring (L, "options");
+ lua_newtable (L);
+ while (opt) {
+ lua_pushstring (L, opt->data);
+ lua_rawseti (L, -2, j++);
+ opt = g_list_next (opt);
+ }
+ lua_settable (L, -3);
+ }
+
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static int
+lua_task_get_symbol (lua_State *L)
+{
+ struct worker_task *task = lua_check_task (L);
+ const char *symbol;
+ struct metric *metric;
+ GList *cur = NULL, *metric_list;
+ gboolean found = FALSE;
+ int i = 1;
+
+ symbol = luaL_checkstring (L, 2);
+
+ if (task && symbol) {
+ metric_list = g_hash_table_lookup (task->cfg->metrics_symbols, symbol);
+ if (metric_list) {
+ lua_newtable (L);
+ cur = metric_list;
+ }
+ else {
+ metric = task->cfg->default_metric;
+ }
+
+ if (!cur && metric) {
+ if ((found = lua_push_symbol_result (L, task, metric, symbol))) {
+ lua_newtable (L);
+ lua_rawseti (L, -2, i++);
+ }
+ }
+ else {
+ while (cur) {
+ metric = cur->data;
+ if (lua_push_symbol_result (L, task, metric, symbol)) {
+ lua_rawseti (L, -2, i++);
+ found = TRUE;
+ }
+ cur = g_list_next (cur);
+ }
+ }
+ }
+
+ if (!found) {
+ lua_pushnil (L);
+ }
+ return 1;
+}
+
+static int
+lua_task_learn_statfile (lua_State *L)
+{
+ struct worker_task *task = lua_check_task (L);
+ const char *symbol;
+ struct classifier_config *cl;
+ GTree *tokens;
+ struct statfile *st;
+ stat_file_t *statfile;
+ struct classifier_ctx *ctx;
+
+ symbol = luaL_checkstring (L, 2);
+
+ if (task && symbol) {
+ cl = g_hash_table_lookup (task->cfg->classifiers_symbols, symbol);
+ if (cl == NULL) {
+ msg_warn ("classifier for symbol %s is not found", symbol);
+ lua_pushboolean (L, FALSE);
+ return 1;
+ }
+ ctx = cl->classifier->init_func (task->task_pool, cl);
+ if ((tokens = g_hash_table_lookup (task->tokens, cl->tokenizer)) == NULL) {
+ msg_warn ("no tokens found learn failed!");
+ lua_pushboolean (L, FALSE);
+ return 1;
+ }
+ statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool, ctx->cfg,
+ symbol, &st, TRUE);
+
+ if (statfile == NULL) {
+ msg_warn ("opening statfile failed!");
+ lua_pushboolean (L, FALSE);
+ return 1;
+ }
+
+ cl->classifier->learn_func (ctx, task->worker->srv->statfile_pool, symbol, tokens, TRUE, NULL, 1., NULL);
+ maybe_write_binlog (ctx->cfg, st, statfile, tokens);
+ lua_pushboolean (L, TRUE);
+ }
+
+ return 1;
+}
+
+static int
+lua_task_get_metric_score (lua_State *L)
+{
+ struct worker_task *task = lua_check_task (L);
+ const char *metric_name;
+ struct metric_result *metric_res;
+
+ metric_name = luaL_checkstring (L, 2);
+
+ if (task && metric_name) {
+ if ((metric_res = g_hash_table_lookup (task->results, metric_name)) != NULL) {
+ lua_newtable (L);
+ lua_pushnumber (L, metric_res->score);
+ lua_rawseti (L, -2, 1);
+ lua_pushnumber (L, metric_res->metric->required_score);
+ lua_rawseti (L, -2, 2);
+ lua_pushnumber (L, metric_res->metric->reject_score);
+ lua_rawseti (L, -2, 3);
+ }
+ else {
+ lua_pushnil (L);
+ }
+ return 1;
+ }
+
+ return 0;
+}
+
+static int
+lua_task_get_metric_action (lua_State *L)
+{
+ struct worker_task *task = lua_check_task (L);
+ const char *metric_name;
+ struct metric_result *metric_res;
+ enum rspamd_metric_action action;
+
+ metric_name = luaL_checkstring (L, 2);
+
+ if (task && metric_name) {
+ if ((metric_res = g_hash_table_lookup (task->results, metric_name)) != NULL) {
+ action = check_metric_action (metric_res->score, metric_res->metric->required_score, metric_res->metric);
+ lua_pushstring (L, str_action_metric (action));
+ }
+ else {
+ lua_pushnil (L);
+ }
+ return 1;
+ }
+
+ return 0;
+}
/**** Textpart implementation *****/
projects / rspamd.git / commitdiff