LUA_FUNCTION_DEF (cryptobox_signature, gc);
LUA_FUNCTION_DEF (cryptobox_hash, create);
LUA_FUNCTION_DEF (cryptobox_hash, create_keyed);
LUA_FUNCTION_DEF (cryptobox_hash, update);
LUA_FUNCTION_DEF (cryptobox_hash, hex);
LUA_FUNCTION_DEF (cryptobox_hash, base32);
LUA_FUNCTION_DEF (cryptobox_hash, base64);
LUA_FUNCTION_DEF (cryptobox_hash, bin);
LUA_FUNCTION_DEF (cryptobox_hash, gc);
LUA_FUNCTION_DEF (cryptobox, verify_memory);
LUA_FUNCTION_DEF (cryptobox, verify_file);
LUA_FUNCTION_DEF (cryptobox, sign_file);
LUA_FUNCTION_DEF (cryptobox, sign_memory);
static const struct luaL_reg cryptoboxlib_f[] = {
LUA_INTERFACE_DEF (cryptobox, verify_memory),
LUA_INTERFACE_DEF (cryptobox, verify_file),
LUA_INTERFACE_DEF (cryptobox, sign_memory),
LUA_INTERFACE_DEF (cryptobox, sign_file),
{NULL, NULL}
};
static const struct luaL_reg cryptoboxpubkeylib_f[] = {
LUA_INTERFACE_DEF (cryptobox_pubkey, load),
LUA_INTERFACE_DEF (cryptobox_pubkey, create),
{NULL, NULL}
};
static const struct luaL_reg cryptoboxpubkeylib_m[] = {
{"__tostring", rspamd_lua_class_tostring},
{"__gc", lua_cryptobox_pubkey_gc},
LUA_FUNCTION_DEF (html, get_images);
/***
* @method html:get_blocks()
* Retruns a table of html blocks. Each block provides the following data:
*
* `tag` - corresponding tag
* `color` - a triplet (r g b) for font color
* `bgcolor` - a triplet (r g b) for background color
* `style` - rspamd{text} with the full style description
* @return {table} table of blocks in html part
*/
LUA_FUNCTION_DEF (html, get_blocks);
static const struct luaL_reg htmllib_m[] = {
LUA_INTERFACE_DEF (html, has_tag),
LUA_INTERFACE_DEF (html, has_property),
LUA_INTERFACE_DEF (html, get_images),
LUA_INTERFACE_DEF (html, get_blocks),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
/***
* @method html_tag:get_type()
* Returns string representation of HTML type for a tag
* @return {string} type of tag
*/
LUA_FUNCTION_DEF (html_tag, get_type);
/***
* @method html_tag:get_extra()
logger.infox('err: %1, data: %2', err, tostring(data))
end
tcp.request({
task = task,
host = "google.com",
port = 80,
data = {"GET / HTTP/1.0\r\n", "Host: google.com\r\n", "\r\n"},
callback = cb})
end
*/
LUA_FUNCTION_DEF (tcp, request);
static const struct luaL_reg tcp_libf[] = {
LUA_INTERFACE_DEF (tcp, request),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
struct lua_tcp_cbdata {
lua_State *L;
struct rspamd_async_session *session;
struct event_base *ev_base;
struct timeval tv;
rspamd_inet_addr_t *addr;
rspamd_mempool_t *pool;
struct iovec *iov;
GString *in;
gchar *stop_pattern;
struct event ev;
local function trie_callback(number, pos)
print('Matched pattern number ' .. tostring(number) .. ' at pos: ' .. tostring(pos))
end
trie:match('some big text', trie_callback)
*/
/* Suffix trie */
LUA_FUNCTION_DEF (trie, create);
LUA_FUNCTION_DEF (trie, match);
LUA_FUNCTION_DEF (trie, search_mime);
LUA_FUNCTION_DEF (trie, search_rawmsg);
LUA_FUNCTION_DEF (trie, destroy);
static const struct luaL_reg trielib_m[] = {
LUA_INTERFACE_DEF (trie, match),
LUA_INTERFACE_DEF (trie, search_mime),
LUA_INTERFACE_DEF (trie, search_rawmsg),
{"__tostring", rspamd_lua_class_tostring},
{"__gc", lua_trie_destroy},
{NULL, NULL}
};
static const struct luaL_reg trielib_f[] = {
LUA_INTERFACE_DEF (trie, create),
{NULL, NULL}
};
static ac_trie_t *
lua_check_trie (lua_State * L, gint idx)
{
void *ud = luaL_checkudata (L, 1, "rspamd{trie}");
LUA_FUNCTION_DEF (rsa_pubkey, create);
LUA_FUNCTION_DEF (rsa_pubkey, gc);
LUA_FUNCTION_DEF (rsa_privkey, load);
LUA_FUNCTION_DEF (rsa_privkey, create);
LUA_FUNCTION_DEF (rsa_privkey, gc);
LUA_FUNCTION_DEF (rsa_signature, create);
LUA_FUNCTION_DEF (rsa_signature, load);
LUA_FUNCTION_DEF (rsa_signature, save);
LUA_FUNCTION_DEF (rsa_signature, gc);
LUA_FUNCTION_DEF (rsa, verify_memory);
LUA_FUNCTION_DEF (rsa, verify_file);
LUA_FUNCTION_DEF (rsa, sign_file);
LUA_FUNCTION_DEF (rsa, sign_memory);
static const struct luaL_reg rsalib_f[] = {
LUA_INTERFACE_DEF (rsa, verify_memory),
LUA_INTERFACE_DEF (rsa, verify_file),
LUA_INTERFACE_DEF (rsa, sign_memory),
LUA_INTERFACE_DEF (rsa, sign_file),
{NULL, NULL}
};
static const struct luaL_reg rsapubkeylib_f[] = {
LUA_INTERFACE_DEF (rsa_pubkey, load),
LUA_INTERFACE_DEF (rsa_pubkey, create),
{NULL, NULL}
};
static const struct luaL_reg rsapubkeylib_m[] = {
{"__tostring", rspamd_lua_class_tostring},
{"__gc", lua_rsa_pubkey_gc},
* @method rspamd_expression:process(input)
* Executes the expression and pass input to process atom callbacks
* @param {any} input input data for processing callbacks
* @return {number} result of the expression evaluation
*/
LUA_FUNCTION_DEF (expr, process);
/***
* @method rspamd_expression:atoms()
* Extract all atoms from the expression as table of strings
* @return {table/strings} list of all atoms in the expression
*/
LUA_FUNCTION_DEF (expr, atoms);
static const struct luaL_reg exprlib_m[] = {
LUA_INTERFACE_DEF (expr, to_string),
LUA_INTERFACE_DEF (expr, atoms),
LUA_INTERFACE_DEF (expr, process),
{"__tostring", lua_expr_to_string},
{NULL, NULL}
};
static const struct luaL_reg exprlib_f[] = {
LUA_INTERFACE_DEF (expr, create),
{NULL, NULL}
};
static rspamd_expression_atom_t * lua_atom_parse (const gchar *line, gsize len,
rspamd_mempool_t *pool, gpointer ud, GError **err);
static gint lua_atom_process (gpointer input, rspamd_expression_atom_t *atom);
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lua_common.h"
#include "cfg_file.h"
/* Classifier methods */
LUA_FUNCTION_DEF (classifier, register_pre_callback);
LUA_FUNCTION_DEF (classifier, register_post_callback);
LUA_FUNCTION_DEF (classifier, get_statfiles);
LUA_FUNCTION_DEF (classifier, get_statfile_by_label);
static const struct luaL_reg classifierlib_m[] = {
LUA_INTERFACE_DEF (classifier, register_pre_callback),
LUA_INTERFACE_DEF (classifier, register_post_callback),
LUA_INTERFACE_DEF (classifier, get_statfiles),
LUA_INTERFACE_DEF (classifier, get_statfile_by_label),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
LUA_FUNCTION_DEF (statfile, get_symbol);
LUA_FUNCTION_DEF (statfile, get_label);
LUA_FUNCTION_DEF (statfile, is_spam);
LUA_FUNCTION_DEF (statfile, get_param);
static const struct luaL_reg statfilelib_m[] = {
LUA_INTERFACE_DEF (statfile, get_symbol),
images = task:get_images()
if images then
-- Symbol `R_EMPTY_IMAGE` is inserted
return true
end
return false
end
end
end
return false
end
*/
LUA_FUNCTION_DEF (config, newindex);
static const struct luaL_reg configlib_m[] = {
LUA_INTERFACE_DEF (config, get_module_opt),
LUA_INTERFACE_DEF (config, get_mempool),
LUA_INTERFACE_DEF (config, get_all_opt),
LUA_INTERFACE_DEF (config, register_function),
LUA_INTERFACE_DEF (config, add_radix_map),
LUA_INTERFACE_DEF (config, add_hash_map),
LUA_INTERFACE_DEF (config, add_kv_map),
LUA_INTERFACE_DEF (config, add_map),
LUA_INTERFACE_DEF (config, get_classifier),
LUA_INTERFACE_DEF (config, register_symbol),
LUA_INTERFACE_DEF (config, register_symbols),
LUA_INTERFACE_DEF (config, register_virtual_symbol),
LUA_INTERFACE_DEF (config, register_callback_symbol),
LUA_INTERFACE_DEF (config, register_callback_symbol_priority),
LUA_INTERFACE_DEF (config, register_module_option),
LUA_INTERFACE_DEF (config, register_pre_filter),
/*
* Fann methods
*/
LUA_FUNCTION_DEF (fann, train);
LUA_FUNCTION_DEF (fann, train_threaded);
LUA_FUNCTION_DEF (fann, test);
LUA_FUNCTION_DEF (fann, save);
LUA_FUNCTION_DEF (fann, data);
LUA_FUNCTION_DEF (fann, get_inputs);
LUA_FUNCTION_DEF (fann, get_outputs);
LUA_FUNCTION_DEF (fann, get_layers);
LUA_FUNCTION_DEF (fann, get_mse);
LUA_FUNCTION_DEF (fann, dtor);
static const struct luaL_reg fannlib_f[] = {
LUA_INTERFACE_DEF (fann, is_enabled),
LUA_INTERFACE_DEF (fann, create),
LUA_INTERFACE_DEF (fann, create_full),
LUA_INTERFACE_DEF (fann, load_file),
{"load", lua_fann_load_file},
LUA_INTERFACE_DEF (fann, load_data),
{NULL, NULL}
};
static const struct luaL_reg fannlib_m[] = {
LUA_INTERFACE_DEF (fann, train),
LUA_INTERFACE_DEF (fann, train_threaded),
LUA_INTERFACE_DEF (fann, test),
LUA_INTERFACE_DEF (fann, save),
LUA_INTERFACE_DEF (fann, data),
LUA_INTERFACE_DEF (fann, get_inputs),
* places, such as periodic events or on_load events.
*/
LUA_FUNCTION_DEF (worker, get_name);
LUA_FUNCTION_DEF (worker, get_stat);
LUA_FUNCTION_DEF (worker, get_index);
LUA_FUNCTION_DEF (worker, get_count);
LUA_FUNCTION_DEF (worker, get_pid);
LUA_FUNCTION_DEF (worker, is_scanner);
LUA_FUNCTION_DEF (worker, is_primary_controller);
LUA_FUNCTION_DEF (worker, spawn_process);
LUA_FUNCTION_DEF (worker, get_mem_stats);
const luaL_reg worker_reg[] = {
LUA_INTERFACE_DEF (worker, get_name),
LUA_INTERFACE_DEF (worker, get_stat),
LUA_INTERFACE_DEF (worker, get_index),
LUA_INTERFACE_DEF (worker, get_count),
LUA_INTERFACE_DEF (worker, get_pid),
LUA_INTERFACE_DEF (worker, spawn_process),
LUA_INTERFACE_DEF (worker, is_scanner),
LUA_INTERFACE_DEF (worker, is_primary_controller),
LUA_INTERFACE_DEF (worker, get_mem_stats),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
static struct rspamd_worker *
lua_check_worker (lua_State *L, gint pos)
{
/***
* @method map:set_callback(cb)
* Set callback for a specified callback map.
* @param {function} cb map callback function
*/
LUA_FUNCTION_DEF (map, set_callback);
/***
* @method map:get_uri()
* Get uri for a specified map
* @return {string} map's URI
*/
LUA_FUNCTION_DEF (map, get_uri);
static const struct luaL_reg maplib_m[] = {
LUA_INTERFACE_DEF (map, get_key),
LUA_INTERFACE_DEF (map, is_signed),
LUA_INTERFACE_DEF (map, get_proto),
LUA_INTERFACE_DEF (map, get_sign_key),
LUA_INTERFACE_DEF (map, set_sign_key),
LUA_INTERFACE_DEF (map, set_callback),
LUA_INTERFACE_DEF (map, get_uri),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
struct lua_map_callback_data {
lua_State *L;
gint ref;
rspamd_fstring_t *data;
struct rspamd_lua_map *lua_map;
ev_base = ev_base, -- if no task available
-- You can include callback and then Rspamd will try to read replies
callback = function(success, data)
-- success is bool, data is either data or an error (string)
end,
retransmits = 0, -- Or more if retransmitting is necessary
}
end
*/
static const double default_udp_timeout = 1.0;
LUA_FUNCTION_DEF (udp, sendto);
static const struct luaL_reg udp_libf[] = {
LUA_INTERFACE_DEF (udp, sendto),
{NULL, NULL}
};
struct lua_udp_cbdata {
struct event io;
struct timeval tv;
struct event_base *ev_base;
struct rspamd_async_event *async_ev;
struct rspamd_task *task;
rspamd_mempool_t *pool;
rspamd_inet_addr_t *addr;
struct rspamd_symcache_item *item;
struct rspamd_async_session *s;
struct iovec *iov;
lua_State *L;
LUA_FUNCTION_DEF (fann, is_enabled);
LUA_FUNCTION_DEF (fann, create);
LUA_FUNCTION_DEF (fann, load);
/*
* Fann methods
*/
LUA_FUNCTION_DEF (fann, train);
LUA_FUNCTION_DEF (fann, test);
LUA_FUNCTION_DEF (fann, save);
LUA_FUNCTION_DEF (fann, get_inputs);
LUA_FUNCTION_DEF (fann, get_outputs);
LUA_FUNCTION_DEF (fann, dtor);
static const struct luaL_reg fannlib_f[] = {
LUA_INTERFACE_DEF (fann, is_enabled),
LUA_INTERFACE_DEF (fann, create),
LUA_INTERFACE_DEF (fann, load),
{NULL, NULL}
};
static const struct luaL_reg fannlib_m[] = {
LUA_INTERFACE_DEF (fann, train),
LUA_INTERFACE_DEF (fann, test),
LUA_INTERFACE_DEF (fann, save),
LUA_INTERFACE_DEF (fann, get_inputs),
LUA_INTERFACE_DEF (fann, get_outputs),
{"__gc", lua_fann_dtor},
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lua_common.h"
#include "cfg_file.h"
/* Classifier methods */
LUA_FUNCTION_DEF (classifier, get_statfiles);
LUA_FUNCTION_DEF (classifier, get_statfile_by_label);
LUA_FUNCTION_DEF (classifier, get_param);
static const struct luaL_reg classifierlib_m[] = {
LUA_INTERFACE_DEF (classifier, get_statfiles),
LUA_INTERFACE_DEF (classifier, get_param),
LUA_INTERFACE_DEF (classifier, get_statfile_by_label),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
LUA_FUNCTION_DEF (statfile, get_symbol);
LUA_FUNCTION_DEF (statfile, get_label);
LUA_FUNCTION_DEF (statfile, is_spam);
LUA_FUNCTION_DEF (statfile, get_param);
static const struct luaL_reg statfilelib_m[] = {
LUA_INTERFACE_DEF (statfile, get_symbol),
LUA_INTERFACE_DEF (statfile, get_label),
LUA_INTERFACE_DEF (statfile, is_spam),
* @method html:foreach_tag(tagname, callback)
* Processes HTML tree calling the specified callback for each tag of the specified
* type.
*
* Callback is called with the following attributes:
*
* - `tag`: html tag structure
* - `content_length`: length of content within a tag
*
* Callback function should return `true` to **stop** processing and `false` to continue
* @return nothing
*/
LUA_FUNCTION_DEF (html, foreach_tag);
static const struct luaL_reg htmllib_m[] = {
LUA_INTERFACE_DEF (html, has_tag),
LUA_INTERFACE_DEF (html, has_property),
LUA_INTERFACE_DEF (html, get_images),
LUA_INTERFACE_DEF (html, get_blocks),
LUA_INTERFACE_DEF (html, foreach_tag),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
/***
* @method html_tag:get_type()
* Returns string representation of HTML type for a tag
* @return {string} type of tag
*/
LUA_FUNCTION_DEF (html_tag, get_type);
/***
rspamd_logger.infox('redis returned %1=%2', redis_key, data)
end
end
rspamd_redis.make_request(task, "127.0.0.1:6379", redis_cb,
'GET', {redis_key})
-- or in table form:
-- rspamd_redis.make_request({task=task, host="127.0.0.1:6379,
-- callback=redis_cb, timeout=2.0, cmd='GET', args={redis_key}})
end
*/
LUA_FUNCTION_DEF (redis, make_request);
static const struct luaL_reg redislib_m[] = {
LUA_INTERFACE_DEF (redis, make_request),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
#ifdef WITH_HIREDIS
/**
* Struct for userdata representation
*/
struct lua_redis_userdata {
redisAsyncContext *ctx;
lua_State *L;
struct rspamd_task *task;
struct event timeout;
gchar *server;
gchar *reqline;
#include <math.h>
/* Public prototypes */
struct rspamd_io_dispatcher_s * lua_check_io_dispatcher (lua_State * L);
void luaopen_io_dispatcher (lua_State * L);
/* Lua bindings */
LUA_FUNCTION_DEF (io_dispatcher, create);
LUA_FUNCTION_DEF (io_dispatcher, set_policy);
LUA_FUNCTION_DEF (io_dispatcher, write);
LUA_FUNCTION_DEF (io_dispatcher, pause);
LUA_FUNCTION_DEF (io_dispatcher, restore);
LUA_FUNCTION_DEF (io_dispatcher, destroy);
static const struct luaL_reg io_dispatcherlib_m[] = {
LUA_INTERFACE_DEF (io_dispatcher, set_policy),
LUA_INTERFACE_DEF (io_dispatcher, write),
LUA_INTERFACE_DEF (io_dispatcher, pause),
LUA_INTERFACE_DEF (io_dispatcher, restore),
LUA_INTERFACE_DEF (io_dispatcher, destroy),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
static const struct luaL_reg io_dispatcherlib_f[] = {
LUA_INTERFACE_DEF (io_dispatcher, create),
{NULL, NULL}
};
struct lua_dispatcher_cbdata {
lua_State *L;
* 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"
LUA_FUNCTION_DEF (xmlrpc, parse_reply);
LUA_FUNCTION_DEF (xmlrpc, make_request);
static const struct luaL_reg xmlrpclib_m[] = {
LUA_INTERFACE_DEF (xmlrpc, parse_reply),
LUA_INTERFACE_DEF (xmlrpc, make_request),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
struct lua_xmlrpc_ud {
gint parser_state;
gint depth;
gint param_count;
gboolean got_text;
lua_State *L;
};
static void xmlrpc_start_element (GMarkupParseContext *context,
const gchar *name,
LUA_FUNCTION_DEF (url, get_path);
LUA_FUNCTION_DEF (url, get_query);
LUA_FUNCTION_DEF (url, get_fragment);
LUA_FUNCTION_DEF (url, get_text);
LUA_FUNCTION_DEF (url, get_tld);
LUA_FUNCTION_DEF (url, to_table);
LUA_FUNCTION_DEF (url, is_phished);
LUA_FUNCTION_DEF (url, is_redirected);
LUA_FUNCTION_DEF (url, is_obscured);
LUA_FUNCTION_DEF (url, get_phished);
LUA_FUNCTION_DEF (url, create);
LUA_FUNCTION_DEF (url, init);
LUA_FUNCTION_DEF (url, all);
static const struct luaL_reg urllib_m[] = {
LUA_INTERFACE_DEF (url, get_length),
LUA_INTERFACE_DEF (url, get_host),
LUA_INTERFACE_DEF (url, get_port),
LUA_INTERFACE_DEF (url, get_user),
LUA_INTERFACE_DEF (url, get_path),
LUA_INTERFACE_DEF (url, get_query),
LUA_INTERFACE_DEF (url, get_fragment),
LUA_INTERFACE_DEF (url, get_text),
LUA_INTERFACE_DEF (url, get_tld),
LUA_INTERFACE_DEF (url, to_table),
LUA_INTERFACE_DEF (url, is_phished),
LUA_INTERFACE_DEF (url, is_redirected),
LUA_INTERFACE_DEF (url, is_obscured),
LUA_INTERFACE_DEF (url, get_phished),
{"get_redirected", lua_url_get_phished},
{"__tostring", lua_url_get_text},
images = task:get_images()
if images then
-- Symbol `R_EMPTY_IMAGE` is inserted
return true
end
return false
end
end
end
return false
end
*/
LUA_FUNCTION_DEF (config, newindex);
static const struct luaL_reg configlib_m[] = {
LUA_INTERFACE_DEF (config, get_module_opt),
LUA_INTERFACE_DEF (config, get_mempool),
LUA_INTERFACE_DEF (config, get_all_opt),
LUA_INTERFACE_DEF (config, add_radix_map),
LUA_INTERFACE_DEF (config, radix_from_config),
LUA_INTERFACE_DEF (config, add_hash_map),
LUA_INTERFACE_DEF (config, add_kv_map),
LUA_INTERFACE_DEF (config, add_map),
LUA_INTERFACE_DEF (config, get_classifier),
LUA_INTERFACE_DEF (config, register_symbol),
LUA_INTERFACE_DEF (config, register_symbols),
LUA_INTERFACE_DEF (config, register_virtual_symbol),
LUA_INTERFACE_DEF (config, register_callback_symbol),
LUA_INTERFACE_DEF (config, register_callback_symbol_priority),
LUA_INTERFACE_DEF (config, register_dependency),
LUA_INTERFACE_DEF (config, set_metric_symbol),
LUA_FUNCTION_DEF (textpart, get_html);
/***
* @method text_part:get_language()
* Returns the code of the most used unicode script in the text part. Does not work with raw parts
* @return {string} short abbreviation (such as `ru`) for the script's language
*/
LUA_FUNCTION_DEF (textpart, get_language);
/***
* @method text_part:get_mimepart()
* Returns the mime part object corresponding to this text part
* @return {mimepart} mimepart object
*/
LUA_FUNCTION_DEF (textpart, get_mimepart);
static const struct luaL_reg textpartlib_m[] = {
LUA_INTERFACE_DEF (textpart, is_utf),
LUA_INTERFACE_DEF (textpart, get_content),
LUA_INTERFACE_DEF (textpart, get_length),
LUA_INTERFACE_DEF (textpart, get_raw_length),
LUA_INTERFACE_DEF (textpart, get_lines_count),
LUA_INTERFACE_DEF (textpart, get_words_count),
LUA_INTERFACE_DEF (textpart, is_empty),
LUA_INTERFACE_DEF (textpart, is_html),
LUA_INTERFACE_DEF (textpart, get_html),
LUA_INTERFACE_DEF (textpart, get_language),
LUA_INTERFACE_DEF (textpart, get_mimepart),
{"__tostring", rspamd_lua_class_tostring},
{NULL, NULL}
};
/* Mimepart methods */
* @param {text or string} input data to decode; if `rspamd{text}` is used then the string is modified **in-place**
* @return {rspamd_text} decoded data chunk
*/
LUA_FUNCTION_DEF (util, decode_base64);
/***
* @function util.tokenize_text(input[, exceptions])
* Create tokens from a text using optional exceptions list
* @param {text/string} input input data
* @param {table} exceptions, a table of pairs containing <start_pos,lenght> of exceptions in the input
* @return {table/strings} list of strings representing words in the text
*/
LUA_FUNCTION_DEF (util, tokenize_text);
LUA_FUNCTION_DEF (util, process_message);
static const struct luaL_reg utillib_f[] = {
LUA_INTERFACE_DEF (util, create_event_base),
LUA_INTERFACE_DEF (util, load_rspamd_config),
LUA_INTERFACE_DEF (util, config_from_ucl),
LUA_INTERFACE_DEF (util, process_message),
LUA_INTERFACE_DEF (util, encode_base64),
LUA_INTERFACE_DEF (util, decode_base64),
LUA_INTERFACE_DEF (util, tokenize_text),
{NULL, NULL}
};
static gint
lua_util_create_event_base (lua_State *L)
{
struct event_base **pev_base;
pev_base = lua_newuserdata (L, sizeof (struct event_base *));
