/* * Copyright (c) 2009, Rambler media * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY Rambler media ''AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL Rambler BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "lua_common.h" #include "../expressions.h" /* Lua module init function */ #define MODULE_INIT_FUNC "module_init" const luaL_reg null_reg[] = { {"__tostring", lua_class_tostring}, {NULL, NULL} }; /* Logger methods */ LUA_FUNCTION_DEF (logger, err); LUA_FUNCTION_DEF (logger, warn); LUA_FUNCTION_DEF (logger, info); LUA_FUNCTION_DEF (logger, debug); static const struct luaL_reg loggerlib_m[] = { LUA_INTERFACE_DEF (logger, err), LUA_INTERFACE_DEF (logger, warn), LUA_INTERFACE_DEF (logger, info), LUA_INTERFACE_DEF (logger, debug), {"__tostring", lua_class_tostring}, {NULL, NULL} }; /* Util functions */ void lua_newclass (lua_State * L, const gchar *classname, const struct luaL_reg *func) { luaL_newmetatable (L, classname); /* mt */ lua_pushstring (L, "__index"); lua_pushvalue (L, -2); /* pushes the metatable */ lua_settable (L, -3); /* metatable.__index = metatable */ lua_pushstring (L, "class"); /* mt,"__index",it,"class" */ lua_pushstring (L, classname); /* mt,"__index",it,"class",classname */ lua_rawset (L, -3); /* mt,"__index",it */ luaL_openlib (L, NULL, func, 0); } gint lua_class_tostring (lua_State * L) { gchar buf[32]; if (!lua_getmetatable (L, 1)) { goto error; } lua_pushstring (L, "__index"); lua_gettable (L, -2); if (!lua_istable (L, -1)) { goto error; } lua_pushstring (L, "class"); lua_gettable (L, -2); if (!lua_isstring (L, -1)) { goto error; } snprintf (buf, sizeof (buf), "%p", lua_touserdata (L, 1)); lua_pushfstring (L, "%s: %s", lua_tostring (L, -1), buf); return 1; error: lua_pushstring (L, "invalid object passed to 'lua_common.c:__tostring'"); lua_error (L); return 1; } void lua_setclass (lua_State * L, const gchar *classname, gint objidx) { luaL_getmetatable (L, classname); if (objidx < 0) { objidx--; } lua_setmetatable (L, objidx); } /* assume that table is at the top */ void lua_set_table_index (lua_State * L, const gchar *index, const gchar *value) { lua_pushstring (L, index); lua_pushstring (L, value); lua_settable (L, -3); } static void lua_common_log (GLogLevelFlags level, lua_State *L, const gchar *msg) { lua_Debug d; gchar func_buf[128], *p; if (lua_getstack (L, 1, &d) == 1) { (void)lua_getinfo(L, "Sl", &d); if ((p = strrchr (d.short_src, '/')) == NULL) { p = d.short_src; } else { p ++; } rspamd_snprintf (func_buf, sizeof (func_buf), "%s:%d", p, d.currentline); if (level == G_LOG_LEVEL_DEBUG) { rspamd_conditional_debug(-1, func_buf, msg); } else { rspamd_common_log_function(level, func_buf, msg); } } else { if (level == G_LOG_LEVEL_DEBUG) { rspamd_conditional_debug(-1, __FUNCTION__, msg); } else { rspamd_common_log_function(level, __FUNCTION__, msg); } } } /*** Logger interface ***/ static gint lua_logger_err (lua_State * L) { const gchar *msg; msg = luaL_checkstring (L, 2); lua_common_log (G_LOG_LEVEL_CRITICAL, L, msg); return 1; } static gint lua_logger_warn (lua_State * L) { const gchar *msg; msg = luaL_checkstring (L, 2); lua_common_log (G_LOG_LEVEL_WARNING, L, msg); return 1; } static gint lua_logger_info (lua_State * L) { const gchar *msg; msg = luaL_checkstring (L, 2); lua_common_log (G_LOG_LEVEL_INFO, L, msg); return 1; } static gint lua_logger_debug (lua_State * L) { const gchar *msg; msg = luaL_checkstring (L, 2); lua_common_log (G_LOG_LEVEL_DEBUG, L, msg); return 1; } /*** Init functions ***/ gint luaopen_rspamd (lua_State * L) { luaL_openlib (L, "rspamd", null_reg, 0); /* make version string available to scripts */ lua_pushstring (L, "_VERSION"); lua_pushstring (L, RVERSION); lua_rawset (L, -3); return 1; } gint luaopen_logger (lua_State * L) { luaL_openlib (L, "rspamd_logger", loggerlib_m, 0); return 1; } void init_lua (struct config_file *cfg) { lua_State *L; L = lua_open (); luaL_openlibs (L); (void)luaopen_rspamd (L); (void)luaopen_logger (L); (void)luaopen_config (L); (void)luaopen_radix (L); (void)luaopen_hash_table (L); (void)luaopen_trie (L); (void)luaopen_task (L); (void)luaopen_textpart (L); (void)luaopen_image (L); (void)luaopen_url (L); (void)luaopen_message (L); (void)luaopen_classifier (L); (void)luaopen_statfile (L); cfg->lua_state = L; memory_pool_add_destructor (cfg->cfg_pool, (pool_destruct_func)lua_close, L); } gboolean init_lua_filters (struct config_file *cfg) { struct config_file **pcfg; GList *cur, *tmp; struct script_module *module; struct statfile *st; lua_State *L = cfg->lua_state; cur = g_list_first (cfg->script_modules); while (cur) { module = cur->data; if (module->path) { if (luaL_loadfile (L, module->path) != 0) { msg_info ("load of %s failed: %s", module->path, lua_tostring (L, -1)); cur = g_list_next (cur); return FALSE; } /* Initialize config structure */ pcfg = lua_newuserdata (L, sizeof (struct config_file *)); lua_setclass (L, "rspamd{config}", -1); *pcfg = cfg; lua_setglobal (L, "rspamd_config"); /* do the call (0 arguments, N result) */ if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) { msg_info ("init of %s failed: %s", module->path, lua_tostring (L, -1)); return FALSE; } if (lua_gettop (L) != 0) { if (lua_tonumber (L, -1) == -1) { msg_info ("%s returned -1 that indicates configuration error", module->path); return FALSE; } lua_pop (L, lua_gettop (L)); } } cur = g_list_next (cur); } /* Init statfiles normalizers */ cur = g_list_first (cfg->statfiles); while (cur) { st = cur->data; if (st->normalizer == lua_normalizer_func) { tmp = st->normalizer_data; if (tmp && (tmp = g_list_next (tmp))) { if (tmp->data) { /* Code must be loaded from data */ if (luaL_loadstring (L, tmp->data) != 0) { msg_info ("cannot load normalizer code %s", tmp->data); return FALSE; } } } } cur = g_list_next (cur); } /* Assign state */ cfg->lua_state = L; return TRUE; } /* Callback functions */ gint lua_call_filter (const gchar *function, struct worker_task *task) { gint result; struct worker_task **ptask; lua_State *L = task->cfg->lua_state; lua_getglobal (L, function); ptask = lua_newuserdata (L, sizeof (struct worker_task *)); lua_setclass (L, "rspamd{task}", -1); *ptask = task; if (lua_pcall (L, 1, 1, 0) != 0) { msg_info ("call to %s failed", function); } /* retrieve result */ if (!lua_isnumber (L, -1)) { msg_info ("function %s must return a number", function); } result = lua_tonumber (L, -1); lua_pop (L, 1); /* pop returned value */ return result; } gint lua_call_chain_filter (const gchar *function, struct worker_task *task, gint *marks, guint number) { gint result, i; lua_State *L = task->cfg->lua_state; lua_getglobal (L, function); for (i = 0; i < number; i++) { lua_pushnumber (L, marks[i]); } if (lua_pcall (L, number, 1, 0) != 0) { msg_info ("call to %s failed", function); } /* retrieve result */ if (!lua_isnumber (L, -1)) { msg_info ("function %s must return a number", function); } result = lua_tonumber (L, -1); lua_pop (L, 1); /* pop returned value */ return result; } /* Call custom lua function in rspamd expression */ gboolean lua_call_expression_func (const gchar *module, const gchar *function, struct worker_task *task, GList *args, gboolean *res) { lua_State *L = task->cfg->lua_state; struct worker_task **ptask; GList *cur; struct expression_argument *arg; int nargs = 1; /* Call specified function and expect result of given expected_type */ /* First check function in config table */ lua_getglobal (L, "config"); if (module != NULL && lua_istable (L, -1)) { lua_pushstring (L, module); lua_gettable (L, -2); if (lua_isnil (L, -1)) { /* Try to get global variable */ lua_getglobal (L, function); } else { /* Call local function in table */ lua_pushstring (L, function); lua_gettable (L, -2); } } else { /* Try to get global variable */ lua_getglobal (L, function); } if (lua_isnil (L, -1)) { msg_err ("function with name %s is not defined", function); return FALSE; } /* Now we got function in top of stack */ ptask = lua_newuserdata (L, sizeof (struct worker_task *)); lua_setclass (L, "rspamd{task}", -1); *ptask = task; /* Now push all arguments */ cur = args; while (cur) { arg = get_function_arg (cur->data, task, FALSE); if (arg) { switch (arg->type) { case EXPRESSION_ARGUMENT_NORMAL: lua_pushstring (L, (const gchar *)arg->data); break; case EXPRESSION_ARGUMENT_BOOL: lua_pushboolean (L, (gboolean) GPOINTER_TO_SIZE (arg->data)); break; default: msg_err ("cannot pass custom params to lua function"); return FALSE; } } nargs ++; cur = g_list_next (cur); } if (lua_pcall (L, nargs, 1, 0) != 0) { msg_info ("call to %s failed: %s", function, lua_tostring (L, -1)); return FALSE; } if (!lua_isboolean (L, -1)) { msg_info ("function %s must return a boolean", function); return FALSE; } *res = lua_toboolean (L, -1); return TRUE; } /* * LUA custom consolidation function */ struct consolidation_callback_data { struct worker_task *task; double score; const gchar *func; }; static void lua_consolidation_callback (gpointer key, gpointer value, gpointer arg) { double res; struct symbol *s = (struct symbol *)value; struct consolidation_callback_data *data = (struct consolidation_callback_data *)arg; lua_State *L = data->task->cfg->lua_state; lua_getglobal (L, data->func); lua_pushstring (L, (const gchar *)key); lua_pushnumber (L, s->score); if (lua_pcall (L, 2, 1, 0) != 0) { msg_info ("call to %s failed", data->func); } /* retrieve result */ if (!lua_isnumber (L, -1)) { msg_info ("function %s must return a number", data->func); } res = lua_tonumber (L, -1); lua_pop (L, 1); /* pop returned value */ data->score += res; } double lua_consolidation_func (struct worker_task *task, const gchar *metric_name, const gchar *function_name) { struct metric_result *metric_res; double res = 0.; struct consolidation_callback_data data = { task, 0, function_name }; if (function_name == NULL) { return 0; } metric_res = g_hash_table_lookup (task->results, metric_name); if (metric_res == NULL) { return res; } g_hash_table_foreach (metric_res->symbols, lua_consolidation_callback, &data); return data.score; } double lua_normalizer_func (struct config_file *cfg, long double score, void *params) { GList *p = params; long double res = score; lua_State *L = cfg->lua_state; /* Call specified function and put input score on stack */ if (!p->data) { msg_info ("bad function name while calling normalizer"); return score; } lua_getglobal (L, p->data); lua_pushnumber (L, score); if (lua_pcall (L, 1, 1, 0) != 0) { msg_info ("call to %s failed", p->data); } /* retrieve result */ if (!lua_isnumber (L, -1)) { msg_info ("function %s must return a number", p->data); } res = lua_tonumber (L, -1); return res; }