rspamd_lua_setclass(L, rspamd_task_classname, -1);
pconn_ent = lua_newuserdata(L, sizeof(*pconn_ent));
*pconn_ent = conn_ent;
- rspamd_lua_setclass(L, "rspamd{csession}", -1);
+ rspamd_lua_setclass(L, rspamd_csession_classname, -1);
lua_pushinteger(L, from);
lua_pushinteger(L, to);
lua_pushboolean(L, reset);
*ptask = task;
pconn = lua_newuserdata(L, sizeof(*pconn));
- rspamd_lua_setclass(L, "rspamd{csession}", -1);
+ rspamd_lua_setclass(L, rspamd_csession_classname, -1);
*pconn = conn_ent;
if (lua_pcall(L, 2, 0, 0) != 0) {
/* Connection */
pconn = lua_newuserdata(L, sizeof(*pconn));
- rspamd_lua_setclass(L, "rspamd{csession}", -1);
+ rspamd_lua_setclass(L, rspamd_csession_classname, -1);
*pconn = conn_ent;
/* Query arguments */
static void
luaopen_controller(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{csession}", lua_csessionlib_m);
+ rspamd_lua_new_class(L, rspamd_csession_classname, lua_csessionlib_m);
lua_pop(L, 1);
}
struct rspamd_http_connection_entry *
lua_check_controller_entry(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{csession}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_csession_classname);
luaL_argcheck(L, ud != NULL, pos, "'csession' expected");
return ud ? *((struct rspamd_http_connection_entry **) ud) : NULL;
}
if (c) {
s = c->ud;
pbase = lua_newuserdata(L, sizeof(struct ev_loop *));
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
*pbase = s->ctx->event_loop;
}
else {
if (c) {
s = c->ud;
pcfg = lua_newuserdata(L, sizeof(gpointer));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = s->ctx->cfg;
}
else {
lua_fuzzy_add_pre_handler(lua_State *L)
{
struct rspamd_worker *wrk, **pwrk = (struct rspamd_worker **)
- rspamd_lua_check_udata(L, 1, "rspamd{worker}");
+ rspamd_lua_check_udata(L, 1, rspamd_worker_classname);
struct rspamd_fuzzy_storage_ctx *ctx;
if (!pwrk) {
lua_fuzzy_add_post_handler(lua_State *L)
{
struct rspamd_worker *wrk, **pwrk = (struct rspamd_worker **)
- rspamd_lua_check_udata(L, 1, "rspamd{worker}");
+ rspamd_lua_check_udata(L, 1, rspamd_worker_classname);
struct rspamd_fuzzy_storage_ctx *ctx;
if (!pwrk) {
lua_fuzzy_add_blacklist_handler(lua_State *L)
{
struct rspamd_worker *wrk, **pwrk = (struct rspamd_worker **)
- rspamd_lua_check_udata(L, 1, "rspamd{worker}");
+ rspamd_lua_check_udata(L, 1, rspamd_worker_classname);
struct rspamd_fuzzy_storage_ctx *ctx;
if (!pwrk) {
.name = "add_fuzzy_pre_handler",
.func = lua_fuzzy_add_pre_handler,
};
- rspamd_lua_add_metamethod(ctx->cfg->lua_state, "rspamd{worker}", &fuzzy_lua_reg);
+ rspamd_lua_add_metamethod(ctx->cfg->lua_state, rspamd_worker_classname, &fuzzy_lua_reg);
fuzzy_lua_reg = (luaL_Reg){
.name = "add_fuzzy_post_handler",
.func = lua_fuzzy_add_post_handler,
};
- rspamd_lua_add_metamethod(ctx->cfg->lua_state, "rspamd{worker}", &fuzzy_lua_reg);
+ rspamd_lua_add_metamethod(ctx->cfg->lua_state, rspamd_worker_classname, &fuzzy_lua_reg);
fuzzy_lua_reg = (luaL_Reg){
.name = "add_fuzzy_blacklist_handler",
.func = lua_fuzzy_add_blacklist_handler,
};
- rspamd_lua_add_metamethod(ctx->cfg->lua_state, "rspamd{worker}", &fuzzy_lua_reg);
+ rspamd_lua_add_metamethod(ctx->cfg->lua_state, rspamd_worker_classname, &fuzzy_lua_reg);
rspamd_lua_run_postloads(ctx->cfg->lua_state, ctx->cfg, ctx->event_loop,
worker);
struct rspamd_task **ptask;
pmime = lua_newuserdata(L, sizeof(struct rspamd_mime_part *));
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
*pmime = part;
ptask = lua_newuserdata(L, sizeof(struct rspamd_task *));
rspamd_lua_setclass(L, rspamd_task_classname, -1);
gint err_idx = lua_gettop(L);
lua_pushvalue(L, magic_func_pos);
pmime = lua_newuserdata(L, sizeof(struct rspamd_mime_part *));
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
*pmime = part;
ptask = lua_newuserdata(L, sizeof(struct rspamd_task *));
rspamd_lua_setclass(L, rspamd_task_classname, -1);
gint err_idx = lua_gettop(L);
lua_pushvalue(L, content_func_pos);
pmime = lua_newuserdata(L, sizeof(struct rspamd_mime_part *));
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
*pmime = part;
ptask = lua_newuserdata(L, sizeof(struct rspamd_task *));
rspamd_lua_setclass(L, rspamd_task_classname, -1);
void *pcfg = lua_newuserdata(RSPAMD_LUA_CFG_STATE(cfg), sizeof(void *));
memcpy(pcfg, &cfg, sizeof(void *));
- rspamd_lua_setclass(RSPAMD_LUA_CFG_STATE(cfg), "rspamd{config}", -1);
+ rspamd_lua_setclass(RSPAMD_LUA_CFG_STATE(cfg), rspamd_config_classname, -1);
if (lua_pcall(RSPAMD_LUA_CFG_STATE(cfg), 1, 0, err_idx) != 0) {
msg_err_config("cannot call lua init_debug_logging script: %s",
if (lua_type(L, -1) == LUA_TFUNCTION) {
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cfg;
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
lua_pushstring(L, sym);
lua_pushnumber(L, score);
if (lua_type(L, -1) == LUA_TFUNCTION) {
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cfg;
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
lua_pushstring(L, action);
lua_pushnumber(L, score);
lua_rawgeti(L, LUA_REGISTRYINDEX, peak_cb);
pbase = (struct ev_loop **) lua_newuserdata(L, sizeof(*pbase));
*pbase = ev_loop;
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
lua_pushlstring(L, item->symbol.c_str(), item->symbol.size());
lua_pushnumber(L, item->st->avg_frequency);
lua_pushnumber(L, ::sqrt(item->st->stddev_frequency));
if (ctx->event_loop) {
auto **pev_base = (struct ev_loop **) lua_newuserdata(L, sizeof(struct ev_loop *));
*pev_base = ctx->event_loop;
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
}
else {
lua_pushnil(L);
rspamd_lua_setclass(L, rspamd_task_classname, -1);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cl->cfg;
- rspamd_lua_setclass(L, "rspamd{classifier}", -1);
+ rspamd_lua_setclass(L, rspamd_classifier_classname, -1);
lua_createtable(L, tokens->len, 0);
rspamd_lua_setclass(L, rspamd_task_classname, -1);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cl->cfg;
- rspamd_lua_setclass(L, "rspamd{classifier}", -1);
+ rspamd_lua_setclass(L, rspamd_classifier_classname, -1);
lua_createtable(L, tokens->len, 0);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cfg;
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
if ((ret = lua_pcall(L, 1, 1, err_idx)) != 0) {
msg_err_config("call to gen_stat_tokens lua "
static struct cdb *
lua_check_cdb(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cdb}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cdb_classname);
luaL_argcheck(L, ud != NULL, pos, "'cdb' expected");
return ud ? *((struct cdb **) ud) : NULL;
static struct cdb_make *
lua_check_cdb_builder(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cdb_builder}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cdb_builder_classname);
luaL_argcheck(L, ud != NULL, pos, "'cdb_builder' expected");
return ud ? ((struct cdb_make *) ud) : NULL;
return numbuf;
}
case LUA_TUSERDATA: {
- void *p = rspamd_lua_check_udata_maybe(L, pos, "rspamd{text}");
+ void *p = rspamd_lua_check_udata_maybe(L, pos, rspamd_text_classname);
if (p) {
struct rspamd_lua_text *t = (struct rspamd_lua_text *) p;
*olen = t->len;
return t->start;
}
- p = rspamd_lua_check_udata_maybe(L, pos, "rspamd{int64}");
+ p = rspamd_lua_check_udata_maybe(L, pos, rspamd_int64_classname);
if (p) {
static char numbuf[sizeof(gint64)];
cdb_add_timer(cdb, ev_base, CDB_REFRESH_TIME);
}
pcdb = lua_newuserdata(L, sizeof(struct cdb *));
- rspamd_lua_setclass(L, "rspamd{cdb}", -1);
+ rspamd_lua_setclass(L, rspamd_cdb_classname, -1);
*pcdb = cdb;
}
}
struct cdb_make *cdbm = lua_newuserdata(L, sizeof(struct cdb_make));
g_assert(cdb_make_start(cdbm, fd) == 0);
- rspamd_lua_setclass(L, "rspamd{cdb_builder}", -1);
+ rspamd_lua_setclass(L, rspamd_cdb_builder_classname, -1);
return 1;
}
void luaopen_cdb(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{cdb}", cdblib_m);
+ rspamd_lua_new_class(L, rspamd_cdb_classname, cdblib_m);
lua_pop(L, 1);
- rspamd_lua_new_class(L, "rspamd{cdb_builder}", cdbbuilderlib_m);
+ rspamd_lua_new_class(L, rspamd_cdb_builder_classname, cdbbuilderlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_cdb", lua_load_cdb);
}
static struct rspamd_classifier_config *
lua_check_classifier(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{classifier}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_classifier_classname);
luaL_argcheck(L, ud != NULL, 1, "'classifier' expected");
return ud ? *((struct rspamd_classifier_config **) ud) : NULL;
}
while (cur) {
st = cur->data;
pst = lua_newuserdata(L, sizeof(struct rspamd_statfile_config *));
- rspamd_lua_setclass(L, "rspamd{statfile}", -1);
+ rspamd_lua_setclass(L, rspamd_statfile_classname, -1);
*pst = st;
lua_rawseti(L, -2, i++);
pst =
lua_newuserdata(L,
sizeof(struct rspamd_statfile_config *));
- rspamd_lua_setclass(L, "rspamd{statfile}", -1);
+ rspamd_lua_setclass(L, rspamd_statfile_classname, -1);
*pst = st;
lua_rawseti(L, -2, i++);
cur = g_list_next(cur);
static struct rspamd_statfile_config *
lua_check_statfile(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{statfile}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_statfile_classname);
luaL_argcheck(L, ud != NULL, 1, "'statfile' expected");
return ud ? *((struct rspamd_statfile_config **) ud) : NULL;
}
void luaopen_classifier(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{classifier}", classifierlib_m);
+ rspamd_lua_new_class(L, rspamd_classifier_classname, classifierlib_m);
lua_pop(L, 1); /* remove metatable from stack */
}
void luaopen_statfile(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{statfile}", statfilelib_m);
+ rspamd_lua_new_class(L, rspamd_statfile_classname, statfilelib_m);
lua_pop(L, 1); /* remove metatable from stack */
}
#include "lua_classnames.h"
+const char *rspamd_archive_classname = "rspamd{archive}";
+const char *rspamd_cdb_builder_classname = "rspamd{cdb_builder}";
+const char *rspamd_cdb_classname = "rspamd{cdb}";
+const char *rspamd_classifier_classname = "rspamd{classifier}";
+const char *rspamd_config_classname = "rspamd{config}";
+const char *rspamd_cryptobox_hash_classname = "rspamd{cryptobox_hash}";
+const char *rspamd_cryptobox_keypair_classname = "rspamd{cryptobox_keypair}";
+const char *rspamd_cryptobox_pubkey_classname = "rspamd{cryptobox_pubkey}";
+const char *rspamd_cryptobox_secretbox_classname = "rspamd{cryptobox_secretbox}";
+const char *rspamd_cryptobox_signature_classname = "rspamd{cryptobox_signature}";
+const char *rspamd_csession_classname = "rspamd{csession}";
+const char *rspamd_ev_base_classname = "rspamd{ev_base}";
+const char *rspamd_expr_classname = "rspamd{expr}";
+const char *rspamd_html_tag_classname = "rspamd{html_tag}";
+const char *rspamd_html_classname = "rspamd{html}";
+const char *rspamd_image_classname = "rspamd{image}";
+const char *rspamd_int64_classname = "rspamd{int64}";
+const char *rspamd_ip_classname = "rspamd{ip}";
+const char *rspamd_kann_node_classname = "rspamd{kann_node}";
+const char *rspamd_kann_classname = "rspamd{kann}";
+const char *rspamd_map_classname = "rspamd{map}";
+const char *rspamd_mempool_classname = "rspamd{mempool}";
+const char *rspamd_mimepart_classname = "rspamd{mimepart}";
+const char *rspamd_monitored_classname = "rspamd{monitored}";
+const char *rspamd_redis_classname = "rspamd{redis}";
+const char *rspamd_regexp_classname = "rspamd{regexp}";
+const char *rspamd_resolver_classname = "rspamd{resolver}";
+const char *rspamd_rsa_privkey_classname = "rspamd{rsa_privkey}";
+const char *rspamd_rsa_pubkey_classname = "rspamd{rsa_pubkey}";
+const char *rspamd_rsa_signature_classname = "rspamd{rsa_signature}";
+const char *rspamd_session_classname = "rspamd{session}";
+const char *rspamd_spf_record_classname = "rspamd{spf_record}";
+const char *rspamd_sqlite3_stmt_classname = "rspamd{sqlite3_stmt}";
+const char *rspamd_sqlite3_classname = "rspamd{sqlite3}";
+const char *rspamd_statfile_classname = "rspamd{statfile}";
const char *rspamd_task_classname = "rspamd{task}";
+const char *rspamd_tcp_sync_classname = "rspamd{tcp_sync}";
+const char *rspamd_tcp_classname = "rspamd{tcp}";
+const char *rspamd_tensor_classname = "rspamd{tensor}";
+const char *rspamd_textpart_classname = "rspamd{textpart}";
+const char *rspamd_text_classname = "rspamd{text}";
+const char *rspamd_trie_classname = "rspamd{trie}";
+const char *rspamd_upstream_list_classname = "rspamd{upstream_list}";
+const char *rspamd_upstream_classname = "rspamd{upstream}";
+const char *rspamd_url_classname = "rspamd{url}";
+const char *rspamd_worker_classname = "rspamd{worker}";
+const char *rspamd_zstd_compress_classname = "rspamd{zstd_compress}";
+const char *rspamd_zstd_decompress_classname = "rspamd{zstd_decompress}";
* Here are static definitions of all classes used in Rspamd Lua API
*/
+extern const char *rspamd_archive_classname;
+extern const char *rspamd_cdb_builder_classname;
+extern const char *rspamd_cdb_classname;
+extern const char *rspamd_classifier_classname;
+extern const char *rspamd_config_classname;
+extern const char *rspamd_cryptobox_hash_classname;
+extern const char *rspamd_cryptobox_keypair_classname;
+extern const char *rspamd_cryptobox_pubkey_classname;
+extern const char *rspamd_cryptobox_secretbox_classname;
+extern const char *rspamd_cryptobox_signature_classname;
+extern const char *rspamd_csession_classname;
+extern const char *rspamd_ev_base_classname;
+extern const char *rspamd_expr_classname;
+extern const char *rspamd_html_tag_classname;
+extern const char *rspamd_html_classname;
+extern const char *rspamd_image_classname;
+extern const char *rspamd_int64_classname;
+extern const char *rspamd_ip_classname;
+extern const char *rspamd_kann_node_classname;
+extern const char *rspamd_kann_classname;
+extern const char *rspamd_map_classname;
+extern const char *rspamd_mempool_classname;
+extern const char *rspamd_mimepart_classname;
+extern const char *rspamd_monitored_classname;
+extern const char *rspamd_redis_classname;
+extern const char *rspamd_regexp_classname;
+extern const char *rspamd_resolver_classname;
+extern const char *rspamd_rsa_privkey_classname;
+extern const char *rspamd_rsa_pubkey_classname;
+extern const char *rspamd_rsa_signature_classname;
+extern const char *rspamd_session_classname;
+extern const char *rspamd_spf_record_classname;
+extern const char *rspamd_sqlite3_stmt_classname;
+extern const char *rspamd_sqlite3_classname;
+extern const char *rspamd_statfile_classname;
extern const char *rspamd_task_classname;
+extern const char *rspamd_tcp_sync_classname;
+extern const char *rspamd_tcp_classname;
+extern const char *rspamd_tensor_classname;
+extern const char *rspamd_textpart_classname;
+extern const char *rspamd_text_classname;
+extern const char *rspamd_trie_classname;
+extern const char *rspamd_upstream_list_classname;
+extern const char *rspamd_upstream_classname;
+extern const char *rspamd_url_classname;
+extern const char *rspamd_worker_classname;
+extern const char *rspamd_zstd_compress_classname;
+extern const char *rspamd_zstd_decompress_classname;
#endif//RSPAMD_LUA_CLASSNAMES_H
if (cfg != NULL) {
pcfg = lua_newuserdata(L, sizeof(struct rspamd_config *));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = cfg;
lua_setglobal(L, "rspamd_config");
}
lua_settop(L, 0);
#endif
- rspamd_lua_new_class(L, "rspamd{session}", NULL);
+ rspamd_lua_new_class(L, rspamd_session_classname, NULL);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "lpeg", luaopen_lpeg);
gint err_idx, i;
pcfg = lua_newuserdata(L, sizeof(struct rspamd_config *));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = cfg;
lua_setglobal(L, "rspamd_config");
struct rspamd_async_session *
lua_check_session(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{session}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_session_classname);
luaL_argcheck(L, ud != NULL, pos, "'session' expected");
return ud ? *((struct rspamd_async_session **) ud) : NULL;
}
struct ev_loop *
lua_check_ev_base(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{ev_base}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_ev_base_classname);
luaL_argcheck(L, ud != NULL, pos, "'event_base' expected");
return ud ? *((struct ev_loop **) ud) : NULL;
}
lua_rawgeti(L, LUA_REGISTRYINDEX, sc->cbref);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cfg;
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
pev_base = lua_newuserdata(L, sizeof(*pev_base));
*pev_base = ev_base;
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
pw = lua_newuserdata(L, sizeof(*pw));
*pw = w;
- rspamd_lua_setclass(L, "rspamd{worker}", -1);
+ rspamd_lua_setclass(L, rspamd_worker_classname, -1);
lua_thread_call(thread, 3);
}
lua_rawgeti(L, LUA_REGISTRYINDEX, sc->cbref);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cfg;
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
if (lua_pcall(L, 1, 0, err_idx) != 0) {
msg_err_config("cannot run config post init script: %s; priority = %d",
lua_rawgeti(L, LUA_REGISTRYINDEX, sc->cbref);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
*pcfg = cfg;
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
if (lua_pcall(L, 1, 0, err_idx) != 0) {
msg_err_config("cannot run config post init script: %s",
/* Function arguments */
ucl_object_push_lua(L, obj, false);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = cfg;
lua_pushboolean(L, false); /* no_fallback */
static ZSTD_CStream *
lua_check_zstd_compress_ctx(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{zstd_compress}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_zstd_compress_classname);
luaL_argcheck(L, ud != NULL, pos, "'zstd_compress' expected");
return ud ? *(ZSTD_CStream **) ud : NULL;
}
static ZSTD_DStream *
lua_check_zstd_decompress_ctx(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{zstd_decompress}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_zstd_decompress_classname);
luaL_argcheck(L, ud != NULL, pos, "'zstd_decompress' expected");
return ud ? *(ZSTD_DStream **) ud : NULL;
}
res = lua_newuserdata(L, sizeof(*res));
res->start = g_malloc(sz);
res->flags = RSPAMD_TEXT_FLAG_OWN;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
r = ZSTD_compress((void *) res->start, sz, t->start, t->len, comp_level);
if (ZSTD_isError(r)) {
res = lua_newuserdata(L, sizeof(*res));
res->start = out;
res->flags = RSPAMD_TEXT_FLAG_OWN;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
res->len = zout.pos;
return 2;
res = lua_newuserdata(L, sizeof(*res));
res->start = g_malloc(sz);
res->flags = RSPAMD_TEXT_FLAG_OWN;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
p = (guchar *) res->start;
remain = sz;
res = lua_newuserdata(L, sizeof(*res));
res->start = g_malloc(sz);
res->flags = RSPAMD_TEXT_FLAG_OWN;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
p = (guchar *) res->start;
remain = sz;
}
*pctx = ctx;
- rspamd_lua_setclass(L, "rspamd{zstd_compress}", -1);
+ rspamd_lua_setclass(L, rspamd_zstd_compress_classname, -1);
return 1;
}
}
*pctx = ctx;
- rspamd_lua_setclass(L, "rspamd{zstd_decompress}", -1);
+ rspamd_lua_setclass(L, rspamd_zstd_decompress_classname, -1);
return 1;
}
void luaopen_compress(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{zstd_compress}", zstd_compress_lib_m);
- rspamd_lua_new_class(L, "rspamd{zstd_decompress}", zstd_decompress_lib_m);
+ rspamd_lua_new_class(L, rspamd_zstd_compress_classname, zstd_compress_lib_m);
+ rspamd_lua_new_class(L, rspamd_zstd_decompress_classname, zstd_decompress_lib_m);
lua_pop(L, 2);
rspamd_lua_add_preload(L, "rspamd_zstd", lua_load_zstd);
struct rspamd_config *
lua_check_config(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{config}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_config_classname);
luaL_argcheck(L, ud != NULL, pos, "'config' expected");
return ud ? *((struct rspamd_config **) ud) : NULL;
}
static struct rspamd_monitored *
lua_check_monitored(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{monitored}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_monitored_classname);
luaL_argcheck(L, ud != NULL, pos, "'monitored' expected");
return ud ? *((struct rspamd_monitored **) ud) : NULL;
}
if (cfg != NULL) {
ppool = lua_newuserdata(L, sizeof(rspamd_mempool_t *));
- rspamd_lua_setclass(L, "rspamd{mempool}", -1);
+ rspamd_lua_setclass(L, rspamd_mempool_classname, -1);
*ppool = cfg->cfg_pool;
}
else {
if (cfg != NULL && cfg->dns_resolver) {
pres = lua_newuserdata(L, sizeof(*pres));
- rspamd_lua_setclass(L, "rspamd{resolver}", -1);
+ rspamd_lua_setclass(L, rspamd_resolver_classname, -1);
*pres = cfg->dns_resolver;
}
else {
if (pclc) {
pclc = lua_newuserdata(L,
sizeof(struct rspamd_classifier_config *));
- rspamd_lua_setclass(L, "rspamd{classifier}", -1);
+ rspamd_lua_setclass(L, rspamd_classifier_classname, -1);
*pclc = clc;
return 1;
}
lua_rawgeti(L, LUA_REGISTRYINDEX, periodic->cbref);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
cfg = periodic->cfg;
*pcfg = cfg;
pev_base = lua_newuserdata(L, sizeof(*pev_base));
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
*pev_base = periodic->event_loop;
lua_pushnumber(L, ev_now(periodic->event_loop));
pres = lua_newuserdata(L, sizeof(res));
*pres = res;
- rspamd_lua_setclass(L, "rspamd{int64}", -1);
+ rspamd_lua_setclass(L, rspamd_int64_classname, -1);
return 1;
}
if (m) {
pm = lua_newuserdata(L, sizeof(*pm));
*pm = m;
- rspamd_lua_setclass(L, "rspamd{monitored}", -1);
+ rspamd_lua_setclass(L, rspamd_monitored_classname, -1);
}
else {
lua_pushnil(L);
lua_pushvalue(L, -2);
pcfg = lua_newuserdata(L, sizeof(*pcfg));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = cfg;
lua_pushstring(L, selector_str);
lua_pushstring(L, delimiter);
void luaopen_config(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{config}", configlib_m);
+ rspamd_lua_new_class(L, rspamd_config_classname, configlib_m);
lua_pop(L, 1);
- rspamd_lua_new_class(L, "rspamd{monitored}", monitoredlib_m);
+ rspamd_lua_new_class(L, rspamd_monitored_classname, monitoredlib_m);
lua_pop(L, 1);
}
static struct rspamd_cryptobox_pubkey *
lua_check_cryptobox_pubkey(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cryptobox_pubkey}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cryptobox_pubkey_classname);
luaL_argcheck(L, ud != NULL, 1, "'cryptobox_pubkey' expected");
return ud ? *((struct rspamd_cryptobox_pubkey **) ud) : NULL;
static struct rspamd_cryptobox_keypair *
lua_check_cryptobox_keypair(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cryptobox_keypair}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cryptobox_keypair_classname);
luaL_argcheck(L, ud != NULL, 1, "'cryptobox_keypair' expected");
return ud ? *((struct rspamd_cryptobox_keypair **) ud) : NULL;
static rspamd_fstring_t *
lua_check_cryptobox_sign(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cryptobox_signature}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cryptobox_signature_classname);
luaL_argcheck(L, ud != NULL, 1, "'cryptobox_signature' expected");
return ud ? *((rspamd_fstring_t **) ud) : NULL;
struct rspamd_lua_cryptobox_hash *
lua_check_cryptobox_hash(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cryptobox_hash}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cryptobox_hash_classname);
luaL_argcheck(L, ud != NULL, 1, "'cryptobox_hash' expected");
return ud ? *((struct rspamd_lua_cryptobox_hash **) ud) : NULL;
static struct rspamd_lua_cryptobox_secretbox *
lua_check_cryptobox_secretbox(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{cryptobox_secretbox}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_cryptobox_secretbox_classname);
luaL_argcheck(L, ud != NULL, 1, "'cryptobox_secretbox' expected");
return ud ? *((struct rspamd_lua_cryptobox_secretbox **) ud) : NULL;
else {
munmap(map, len);
ppkey = lua_newuserdata(L, sizeof(void *));
- rspamd_lua_setclass(L, "rspamd{cryptobox_pubkey}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_pubkey_classname, -1);
*ppkey = pkey;
}
}
}
else {
ppkey = lua_newuserdata(L, sizeof(void *));
- rspamd_lua_setclass(L, "rspamd{cryptobox_pubkey}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_pubkey_classname, -1);
*ppkey = pkey;
}
}
else {
pkp = lua_newuserdata(L, sizeof(gpointer));
*pkp = kp;
- rspamd_lua_setclass(L, "rspamd{cryptobox_keypair}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_keypair_classname, -1);
ucl_object_unref(obj);
}
}
else {
pkp = lua_newuserdata(L, sizeof(gpointer));
*pkp = kp;
- rspamd_lua_setclass(L, "rspamd{cryptobox_keypair}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_keypair_classname, -1);
ucl_object_unref(obj);
}
}
pkp = lua_newuserdata(L, sizeof(gpointer));
*pkp = kp;
- rspamd_lua_setclass(L, "rspamd{cryptobox_keypair}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_keypair_classname, -1);
return 1;
}
ppk = lua_newuserdata(L, sizeof(*ppk));
*ppk = pk;
- rspamd_lua_setclass(L, "rspamd{cryptobox_pubkey}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_pubkey_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
if (st.st_size > 0) {
sig = rspamd_fstring_new_init(data, st.st_size);
psig = lua_newuserdata(L, sizeof(rspamd_fstring_t *));
- rspamd_lua_setclass(L, "rspamd{cryptobox_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_signature_classname, -1);
*psig = sig;
}
else {
if (dlen == rspamd_cryptobox_signature_bytes(RSPAMD_CRYPTOBOX_MODE_25519)) {
sig = rspamd_fstring_new_init(data, dlen);
psig = lua_newuserdata(L, sizeof(rspamd_fstring_t *));
- rspamd_lua_setclass(L, "rspamd{cryptobox_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_signature_classname, -1);
*psig = sig;
}
}
ph = lua_newuserdata(L, sizeof(void *));
*ph = h;
- rspamd_lua_setclass(L, "rspamd{cryptobox_hash}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_hash_classname, -1);
return 1;
}
ph = lua_newuserdata(L, sizeof(void *));
*ph = h;
- rspamd_lua_setclass(L, "rspamd{cryptobox_hash}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_hash_classname, -1);
return 1;
}
ph = lua_newuserdata(L, sizeof(void *));
*ph = h;
- rspamd_lua_setclass(L, "rspamd{cryptobox_hash}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_hash_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
ph = lua_newuserdata(L, sizeof(void *));
*ph = h;
- rspamd_lua_setclass(L, "rspamd{cryptobox_hash}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_hash_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
ph = lua_newuserdata(L, sizeof(void *));
*ph = h;
REF_RETAIN(h);
- rspamd_lua_setclass(L, "rspamd{cryptobox_hash}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_hash_classname, -1);
return 1;
}
ph = lua_newuserdata(L, sizeof(void *));
*ph = h;
REF_RETAIN(h);
- rspamd_lua_setclass(L, "rspamd{cryptobox_hash}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_hash_classname, -1);
return 1;
}
sig->len = siglen;
psig = lua_newuserdata(L, sizeof(void *));
*psig = sig;
- rspamd_lua_setclass(L, "rspamd{cryptobox_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_signature_classname, -1);
return 1;
}
sig->len = siglen;
psig = lua_newuserdata(L, sizeof(void *));
*psig = sig;
- rspamd_lua_setclass(L, "rspamd{cryptobox_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_signature_classname, -1);
munmap(data, len);
}
bool owned_pk = false;
if (lua_type(L, 1) == LUA_TUSERDATA) {
- if (rspamd_lua_check_udata_maybe(L, 1, "rspamd{cryptobox_keypair}")) {
+ if (rspamd_lua_check_udata_maybe(L, 1, rspamd_cryptobox_keypair_classname)) {
kp = lua_check_cryptobox_keypair(L, 1);
}
- else if (rspamd_lua_check_udata_maybe(L, 1, "rspamd{cryptobox_pubkey}")) {
+ else if (rspamd_lua_check_udata_maybe(L, 1, rspamd_cryptobox_pubkey_classname)) {
pk = lua_check_cryptobox_pubkey(L, 1);
}
}
res->flags = RSPAMD_TEXT_FLAG_OWN;
res->start = out;
res->len = outlen;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
if (owned_pk) {
rspamd_pubkey_unref(pk);
bool own_pk = false;
if (lua_type(L, 1) == LUA_TUSERDATA) {
- if (rspamd_lua_check_udata_maybe(L, 1, "rspamd{cryptobox_keypair}")) {
+ if (rspamd_lua_check_udata_maybe(L, 1, rspamd_cryptobox_keypair_classname)) {
kp = lua_check_cryptobox_keypair(L, 1);
}
- else if (rspamd_lua_check_udata_maybe(L, 1, "rspamd{cryptobox_pubkey}")) {
+ else if (rspamd_lua_check_udata_maybe(L, 1, rspamd_cryptobox_pubkey_classname)) {
pk = lua_check_cryptobox_pubkey(L, 1);
}
}
res->flags = RSPAMD_TEXT_FLAG_OWN;
res->start = out;
res->len = outlen;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
munmap(data, len);
if (own_pk) {
rspamd_pubkey_unref(pk);
res->flags = RSPAMD_TEXT_FLAG_OWN;
res->start = out;
res->len = outlen;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
}
return 2;
res->flags = RSPAMD_TEXT_FLAG_OWN;
res->start = out;
res->len = outlen;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
}
munmap(data, len);
b64_data = rspamd_encode_base64(data, len, -1, &b64_len);
priv_out = lua_newuserdata(L, sizeof(*priv_out));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
priv_out->start = b64_data;
priv_out->len = b64_len;
priv_out->flags = RSPAMD_TEXT_FLAG_OWN | RSPAMD_TEXT_FLAG_WIPE;
b64_data = rspamd_encode_base64(data, len, -1, &b64_len);
pub_out = lua_newuserdata(L, sizeof(*pub_out));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
pub_out->start = b64_data;
pub_out->len = b64_len;
pub_out->flags = RSPAMD_TEXT_FLAG_OWN;
-1, &b64_len);
priv_out = lua_newuserdata(L, sizeof(*priv_out));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
priv_out->start = b64_data;
priv_out->len = b64_len;
priv_out->flags = RSPAMD_TEXT_FLAG_OWN | RSPAMD_TEXT_FLAG_WIPE;
-1, &b64_len);
pub_out = lua_newuserdata(L, sizeof(*pub_out));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
pub_out->start = b64_data;
pub_out->len = b64_len;
pub_out->flags = RSPAMD_TEXT_FLAG_OWN;
-1, &b64_len);
priv_out = lua_newuserdata(L, sizeof(*priv_out));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
priv_out->start = b64_data;
priv_out->len = b64_len;
priv_out->flags = RSPAMD_TEXT_FLAG_OWN | RSPAMD_TEXT_FLAG_WIPE;
-1, &b64_len);
pub_out = lua_newuserdata(L, sizeof(*pub_out));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
pub_out->start = b64_data;
pub_out->len = b64_len;
pub_out->flags = RSPAMD_TEXT_FLAG_OWN;
crypto_generichash(sbox->sk, sizeof(sbox->sk), in, inlen, NULL, 0);
psbox = lua_newuserdata(L, sizeof(*psbox));
*psbox = sbox;
- rspamd_lua_setclass(L, "rspamd{cryptobox_secretbox}", -1);
+ rspamd_lua_setclass(L, rspamd_cryptobox_secretbox_classname, -1);
return 1;
}
void luaopen_cryptobox(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{cryptobox_pubkey}", cryptoboxpubkeylib_m);
+ rspamd_lua_new_class(L, rspamd_cryptobox_pubkey_classname, cryptoboxpubkeylib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_cryptobox_pubkey", lua_load_pubkey);
- rspamd_lua_new_class(L, "rspamd{cryptobox_keypair}", cryptoboxkeypairlib_m);
+ rspamd_lua_new_class(L, rspamd_cryptobox_keypair_classname, cryptoboxkeypairlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_cryptobox_keypair", lua_load_keypair);
- rspamd_lua_new_class(L, "rspamd{cryptobox_signature}", cryptoboxsignlib_m);
+ rspamd_lua_new_class(L, rspamd_cryptobox_signature_classname, cryptoboxsignlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_cryptobox_signature", lua_load_signature);
- rspamd_lua_new_class(L, "rspamd{cryptobox_hash}", cryptoboxhashlib_m);
+ rspamd_lua_new_class(L, rspamd_cryptobox_hash_classname, cryptoboxhashlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_cryptobox_hash", lua_load_hash);
- rspamd_lua_new_class(L, "rspamd{cryptobox_secretbox}",
+ rspamd_lua_new_class(L, rspamd_cryptobox_secretbox_classname,
cryptoboxsecretboxlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_cryptobox_secretbox",
struct rspamd_dns_resolver *
lua_check_dns_resolver(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{resolver}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_resolver_classname);
luaL_argcheck(L, ud != NULL, pos, "'resolver' expected");
return ud ? *((struct rspamd_dns_resolver **) ud) : NULL;
}
lua_rawgeti(L, LUA_REGISTRYINDEX, cd->cbref);
presolver = lua_newuserdata(L, sizeof(gpointer));
- rspamd_lua_setclass(L, "rspamd{resolver}", -1);
+ rspamd_lua_setclass(L, rspamd_resolver_classname, -1);
*presolver = cd->resolver;
lua_pushstring(L, cd->to_resolve);
struct ev_loop *base, **pbase;
/* Check args */
- pbase = rspamd_lua_check_udata(L, 1, "rspamd{ev_base}");
+ pbase = rspamd_lua_check_udata(L, 1, rspamd_ev_base_classname);
luaL_argcheck(L, pbase != NULL, 1, "'ev_base' expected");
base = pbase ? *(pbase) : NULL;
- pcfg = rspamd_lua_check_udata(L, 2, "rspamd{config}");
+ pcfg = rspamd_lua_check_udata(L, 2, rspamd_config_classname);
luaL_argcheck(L, pcfg != NULL, 2, "'config' expected");
cfg = pcfg ? *(pcfg) : NULL;
resolver = rspamd_dns_resolver_init(NULL, base, cfg);
if (resolver) {
presolver = lua_newuserdata(L, sizeof(gpointer));
- rspamd_lua_setclass(L, "rspamd{resolver}", -1);
+ rspamd_lua_setclass(L, rspamd_resolver_classname, -1);
*presolver = resolver;
}
else {
guint conv_len = 0;
const gchar *hname = luaL_checklstring(L, 2, &hlen);
gchar *converted;
- rspamd_mempool_t *pool = rspamd_lua_check_udata_maybe(L, 3, "rspamd{mempool}");
+ rspamd_mempool_t *pool = rspamd_lua_check_udata_maybe(L, 3, rspamd_mempool_classname);
if (dns_resolver && hname) {
void luaopen_dns_resolver(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{resolver}", dns_resolverlib_m);
+ rspamd_lua_new_class(L, rspamd_resolver_classname, dns_resolverlib_m);
{
LUA_ENUM(L, DNS_A, RDNS_REQUEST_A);
LUA_ENUM(L, DNS_PTR, RDNS_REQUEST_PTR);
struct lua_expression *
rspamd_lua_expression(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{expr}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_expr_classname);
luaL_argcheck(L, ud != NULL, pos, "'expr' expected");
return ud ? *((struct lua_expression **) ud) : NULL;
}
rspamd_mempool_add_destructor(pool, lua_expr_dtor, e);
pe = lua_newuserdata(L, sizeof(struct lua_expression *));
- rspamd_lua_setclass(L, "rspamd{expr}", -1);
+ rspamd_lua_setclass(L, rspamd_expr_classname, -1);
*pe = e;
lua_pushnil(L);
}
void luaopen_expression(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{expr}", exprlib_m);
+ rspamd_lua_new_class(L, rspamd_expr_classname, exprlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_expression", lua_load_expression);
}
static struct rspamd::html::html_content *
lua_check_html(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{html}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_html_classname);
luaL_argcheck(L, ud != NULL, pos, "'html' expected");
return ud ? *((struct rspamd::html::html_content **) ud) : NULL;
}
static struct lua_html_tag *
lua_check_html_tag(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{html_tag}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_html_tag_classname);
luaL_argcheck(L, ud != NULL, pos, "'html_tag' expected");
return ud ? ((struct lua_html_tag *) ud) : NULL;
}
t->len = strlen(img->src);
t->flags = 0;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
}
else {
lua_pushstring(L, img->src);
lua_pushstring(L, "url");
purl = static_cast<rspamd_url **>(lua_newuserdata(L, sizeof(gpointer)));
*purl = img->url;
- rspamd_lua_setclass(L, "rspamd{url}", -1);
+ rspamd_lua_setclass(L, rspamd_url_classname, -1);
lua_settable(L, -3);
}
ltag = static_cast<lua_html_tag *>(lua_newuserdata(L, sizeof(struct lua_html_tag)));
ltag->tag = static_cast<rspamd::html::html_tag *>(img->tag);
ltag->html = NULL;
- rspamd_lua_setclass(L, "rspamd{html_tag}", -1);
+ rspamd_lua_setclass(L, rspamd_html_tag_classname, -1);
lua_settable(L, -3);
}
ltag->tag = tag;
ltag->html = hc;
auto ct = ltag->tag->get_content(hc);
- rspamd_lua_setclass(L, "rspamd{html_tag}", -1);
+ rspamd_lua_setclass(L, rspamd_html_tag_classname, -1);
lua_pushinteger(L, ct.size());
/* Leaf flag */
ptag = static_cast<lua_html_tag *>(lua_newuserdata(L, sizeof(*ptag)));
ptag->tag = static_cast<rspamd::html::html_tag *>(parent);
ptag->html = ltag->html;
- rspamd_lua_setclass(L, "rspamd{html_tag}", -1);
+ rspamd_lua_setclass(L, rspamd_html_tag_classname, -1);
}
else {
lua_pushnil(L);
auto ct = ltag->tag->get_content(ltag->html);
if (ct.size() > 0) {
t = static_cast<rspamd_lua_text *>(lua_newuserdata(L, sizeof(*t)));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = ct.data();
t->len = ct.size();
t->flags = 0;
/* For A that's URL */
auto *lua_url = static_cast<rspamd_lua_url *>(lua_newuserdata(L, sizeof(rspamd_lua_url)));
lua_url->url = std::get<struct rspamd_url *>(ltag->tag->extra);
- rspamd_lua_setclass(L, "rspamd{url}", -1);
+ rspamd_lua_setclass(L, rspamd_url_classname, -1);
}
else {
/* Unknown extra ? */
void luaopen_html(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{html}", htmllib_m);
+ rspamd_lua_new_class(L, rspamd_html_classname, htmllib_m);
lua_pop(L, 1);
- rspamd_lua_new_class(L, "rspamd{html_tag}", taglib_m);
+ rspamd_lua_new_class(L, rspamd_html_tag_classname, taglib_m);
lua_pop(L, 1);
}
struct rspamd_lua_text *t;
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = body;
t->len = body_len;
t->flags = 0;
struct rspamd_lua_text *t;
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = body;
t->len = body_len;
t->flags = 0;
lua_pushvalue(L, 2);
cbref = luaL_ref(L, LUA_REGISTRYINDEX);
- if (lua_gettop(L) >= 3 && rspamd_lua_check_udata_maybe(L, 3, "rspamd{ev_base}")) {
+ if (lua_gettop(L) >= 3 && rspamd_lua_check_udata_maybe(L, 3, rspamd_ev_base_classname)) {
ev_base = *(struct ev_loop **) lua_touserdata(L, 3);
}
else {
ev_base = NULL;
}
- if (lua_gettop(L) >= 4 && rspamd_lua_check_udata_maybe(L, 4, "rspamd{resolver}")) {
+ if (lua_gettop(L) >= 4 && rspamd_lua_check_udata_maybe(L, 4, rspamd_resolver_classname)) {
resolver = *(struct rspamd_dns_resolver **) lua_touserdata(L, 4);
}
else {
resolver = lua_http_global_resolver(ev_base);
}
- if (lua_gettop(L) >= 5 && rspamd_lua_check_udata_maybe(L, 5, "rspamd{session}")) {
+ if (lua_gettop(L) >= 5 && rspamd_lua_check_udata_maybe(L, 5, rspamd_session_classname)) {
session = *(struct rspamd_async_session **) lua_touserdata(L, 5);
}
else {
if (task == NULL) {
lua_pushstring(L, "ev_base");
lua_gettable(L, 1);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{ev_base}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_ev_base_classname)) {
ev_base = *(struct ev_loop **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "session");
lua_gettable(L, 1);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{session}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_session_classname)) {
session = *(struct rspamd_async_session **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "config");
lua_gettable(L, 1);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{config}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_config_classname)) {
cfg = *(struct rspamd_config **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "resolver");
lua_gettable(L, 1);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{resolver}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_resolver_classname)) {
resolver = *(struct rspamd_dns_resolver **) lua_touserdata(L, -1);
}
else {
}
pip = lua_newuserdata(L, sizeof(struct rspamd_lua_ip *));
- rspamd_lua_setclass(L, "rspamd{ip}", -1);
+ rspamd_lua_setclass(L, rspamd_ip_classname, -1);
*pip = ip;
struct rspamd_lua_ip *
lua_check_ip(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{ip}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_ip_classname);
luaL_argcheck(L, ud != NULL, pos, "'ip' expected");
return ud ? *((struct rspamd_lua_ip **) ud) : NULL;
ip = g_malloc0(sizeof(struct rspamd_lua_ip));
ip->addr = rspamd_inet_address_copy(addr, NULL);
pip = lua_newuserdata(L, sizeof(struct rspamd_lua_ip *));
- rspamd_lua_setclass(L, "rspamd{ip}", -1);
+ rspamd_lua_setclass(L, rspamd_ip_classname, -1);
*pip = ip;
}
else {
ip_str, strlen(ip_str), RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
pip = lua_newuserdata(L, sizeof(struct rspamd_lua_ip *));
- rspamd_lua_setclass(L, "rspamd{ip}", -1);
+ rspamd_lua_setclass(L, rspamd_ip_classname, -1);
*pip = ip;
}
else {
void luaopen_ip(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{ip}", iplib_m);
+ rspamd_lua_new_class(L, rspamd_ip_classname, iplib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_ip", lua_load_ip);
}
* `rspamd_kann` is a Lua interface to kann library
*/
-#define KANN_NODE_CLASS "rspamd{kann_node}"
-#define KANN_NETWORK_CLASS "rspamd{kann}"
+#define KANN_NODE_CLASS rspamd_kann_node_classname
+#define KANN_NETWORK_CLASS rspamd_kann_classname
/* Simple macros to define behaviour */
#define KANN_LAYER_DEF(name) static int lua_kann_layer_##name(lua_State *L)
fclose(f);
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->flags = RSPAMD_TEXT_FLAG_OWN;
t->start = (const gchar *) buf;
t->len = buflen;
EINVAL, "invalid rspamd{task}");
}
}
- else if (strcmp(clsname, "rspamd{mempool}") == 0) {
+ else if (strcmp(clsname, rspamd_mempool_classname) == 0) {
rspamd_mempool_t *pool;
pool = rspamd_lua_check_mempool(L, pos);
EINVAL, "invalid rspamd{mempool}");
}
}
- else if (strcmp(clsname, "rspamd{config}") == 0) {
+ else if (strcmp(clsname, rspamd_config_classname) == 0) {
struct rspamd_config *cfg;
cfg = lua_check_config(L, pos);
EINVAL, "invalid rspamd{config}");
}
}
- else if (strcmp(clsname, "rspamd{map}") == 0) {
+ else if (strcmp(clsname, rspamd_map_classname) == 0) {
struct rspamd_lua_map *map;
map = lua_check_map(L, pos);
struct rspamd_lua_map *
lua_check_map(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{map}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_map_classname);
luaL_argcheck(L, ud != NULL, pos, "'map' expected");
return ud ? *((struct rspamd_lua_map **) ud) : NULL;
}
m->lua_map = map;
pmap = lua_newuserdata(L, sizeof(void *));
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
map->map = m;
m->lua_map = map;
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
}
else {
msg_warn_config("Couldnt find config option [%s][%s]", mname,
map->map = m;
m->lua_map = map;
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
m->lua_map = map;
pmap = lua_newuserdata(L, sizeof(void *));
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
m->lua_map = map;
pmap = lua_newuserdata(L, sizeof(void *));
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
struct rspamd_lua_text *t;
t = lua_newuserdata(cbdata->L, sizeof(*t));
- rspamd_lua_setclass(cbdata->L, "rspamd{text}", -1);
+ rspamd_lua_setclass(cbdata->L, rspamd_text_classname, -1);
t->flags = 0;
t->len = cbdata->data->len;
t->start = cbdata->data->str;
pmap = lua_newuserdata(cbdata->L, sizeof(void *));
*pmap = cbdata->lua_map;
- rspamd_lua_setclass(cbdata->L, "rspamd{map}", -1);
+ rspamd_lua_setclass(cbdata->L, rspamd_map_classname, -1);
gint ret = lua_pcall(cbdata->L, 2, 0, err_idx);
map->map = m;
pmap = lua_newuserdata(L, sizeof(void *));
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
pmap = lua_newuserdata(L, sizeof(*pmap));
*pmap = map;
- rspamd_lua_setclass(L, "rspamd{map}", -1);
+ rspamd_lua_setclass(L, rspamd_map_classname, -1);
lua_rawseti(L, -2, i);
cur = g_list_next(cur);
}
}
else if (lua_type(L, 2) == LUA_TUSERDATA) {
- ud = rspamd_lua_check_udata(L, 2, "rspamd{ip}");
+ ud = rspamd_lua_check_udata(L, 2, rspamd_ip_classname);
if (ud != NULL) {
addr = *((struct rspamd_lua_ip **) ud);
void luaopen_map(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{map}", maplib_m);
+ rspamd_lua_new_class(L, rspamd_map_classname, maplib_m);
lua_pop(L, 1);
}
struct memory_pool_s *
rspamd_lua_check_mempool(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{mempool}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_mempool_classname);
luaL_argcheck(L, ud != NULL, pos, "'mempool' expected");
return ud ? *((struct memory_pool_s **) ud) : NULL;
}
if (mempool) {
pmempool = lua_newuserdata(L, sizeof(struct memory_pool_s *));
- rspamd_lua_setclass(L, "rspamd{mempool}", -1);
+ rspamd_lua_setclass(L, rspamd_mempool_classname, -1);
*pmempool = mempool;
}
else {
void luaopen_mempool(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{mempool}", mempoollib_m);
+ rspamd_lua_new_class(L, rspamd_mempool_classname, mempoollib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_mempool", lua_load_mempool);
}
static struct rspamd_mime_text_part *
lua_check_textpart(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{textpart}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_textpart_classname);
luaL_argcheck(L, ud != NULL, 1, "'textpart' expected");
return ud ? *((struct rspamd_mime_text_part **) ud) : NULL;
}
static struct rspamd_mime_part *
lua_check_mimepart(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{mimepart}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_mimepart_classname);
luaL_argcheck(L, ud != NULL, 1, "'mimepart' expected");
return ud ? *((struct rspamd_mime_part **) ud) : NULL;
}
}
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = start;
t->len = len;
}
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = part->raw.begin;
t->len = part->raw.len;
t->flags = 0;
}
else {
phc = lua_newuserdata(L, sizeof(*phc));
- rspamd_lua_setclass(L, "rspamd{html}", -1);
+ rspamd_lua_setclass(L, rspamd_html_classname, -1);
*phc = part->html;
}
if (part != NULL) {
if (part->mime_part != NULL) {
pmime = lua_newuserdata(L, sizeof(struct rspamd_mime_part *));
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
*pmime = part->mime_part;
return 1;
}
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = part->parsed_data.begin;
t->len = part->parsed_data.len;
t->flags = 0;
}
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = part->raw_data.begin;
t->len = part->raw_data.len;
t->flags = 0;
if (part) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = part->raw_headers_str;
t->len = part->raw_headers_len;
t->flags = 0;
else {
pimg = lua_newuserdata(L, sizeof(*pimg));
*pimg = part->specific.img;
- rspamd_lua_setclass(L, "rspamd{image}", -1);
+ rspamd_lua_setclass(L, rspamd_image_classname, -1);
}
return 1;
else {
parch = lua_newuserdata(L, sizeof(*parch));
*parch = part->specific.arch;
- rspamd_lua_setclass(L, "rspamd{archive}", -1);
+ rspamd_lua_setclass(L, rspamd_archive_classname, -1);
}
return 1;
{
pcur = lua_newuserdata(L, sizeof(*pcur));
*pcur = cur;
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
lua_rawseti(L, -2, i + 1);
}
}
if (part->parent_part) {
pparent = lua_newuserdata(L, sizeof(*pparent));
*pparent = part->parent_part;
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
}
else {
lua_pushnil(L);
else {
ppart = lua_newuserdata(L, sizeof(*ppart));
*ppart = part->specific.txt;
- rspamd_lua_setclass(L, "rspamd{textpart}", -1);
+ rspamd_lua_setclass(L, rspamd_textpart_classname, -1);
}
return 1;
lua_gettable(L, 3);
if (lua_isuserdata(L, -1)) {
- RSPAMD_LUA_CHECK_UDATA_PTR_OR_RETURN(L, -1, "rspamd{regexp}",
+ RSPAMD_LUA_CHECK_UDATA_PTR_OR_RETURN(L, -1, rspamd_regexp_classname,
struct rspamd_lua_regexp, re);
}
part->specific.lua_specific.type = RSPAMD_LUA_PART_STRING;
break;
case LUA_TUSERDATA:
- if (rspamd_lua_check_udata_maybe(L, 2, "rspamd{text}")) {
+ if (rspamd_lua_check_udata_maybe(L, 2, rspamd_text_classname)) {
part->specific.lua_specific.type = RSPAMD_LUA_PART_TEXT;
}
else {
void luaopen_textpart(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{textpart}", textpartlib_m);
+ rspamd_lua_new_class(L, rspamd_textpart_classname, textpartlib_m);
lua_pop(L, 1);
}
void luaopen_mimepart(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{mimepart}", mimepartlib_m);
+ rspamd_lua_new_class(L, rspamd_mimepart_classname, mimepartlib_m);
lua_pop(L, 1);
}
static struct lua_redis_ctx *
lua_check_redis(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{redis}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_redis_classname);
luaL_argcheck(L, ud != NULL, pos, "'redis' expected");
return ud ? *((struct lua_redis_ctx **) ud) : NULL;
}
case REDIS_REPLY_STATUS:
if (text_data) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->flags = 0;
t->start = r->str;
t->len = r->len;
if (ret) {
pctx = lua_newuserdata(L, sizeof(ctx));
*pctx = ctx;
- rspamd_lua_setclass(L, "rspamd{redis}", -1);
+ rspamd_lua_setclass(L, rspamd_redis_classname, -1);
}
else {
lua_pushnil(L);
lua_pushboolean(L, TRUE);
pctx = lua_newuserdata(L, sizeof(ctx));
*pctx = ctx;
- rspamd_lua_setclass(L, "rspamd{redis}", -1);
+ rspamd_lua_setclass(L, rspamd_redis_classname, -1);
return 2;
}
lua_pushboolean(L, TRUE);
pctx = lua_newuserdata(L, sizeof(ctx));
*pctx = ctx;
- rspamd_lua_setclass(L, "rspamd{redis}", -1);
+ rspamd_lua_setclass(L, rspamd_redis_classname, -1);
}
else {
lua_pushboolean(L, FALSE);
*/
void luaopen_redis(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{redis}", redislib_m);
+ rspamd_lua_new_class(L, rspamd_redis_classname, redislib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_redis", lua_load_redis);
struct rspamd_lua_regexp *
lua_check_regexp(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{regexp}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_regexp_classname);
luaL_argcheck(L, ud != NULL, pos, "'regexp' expected");
return ud ? *((struct rspamd_lua_regexp **) ud) : NULL;
new->re_pattern = g_strdup(string);
new->module = rspamd_lua_get_module_name(L);
pnew = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pnew = new;
}
}
new->re_pattern = escaped;
new->module = rspamd_lua_get_module_name(L);
pnew = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pnew = new;
}
}
new->re_pattern = escaped;
new->module = rspamd_lua_get_module_name(L);
pnew = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pnew = new;
}
}
new->re_pattern = g_strdup(string);
new->module = rspamd_lua_get_module_name(L);
pnew = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pnew = new;
}
else {
new->module = rspamd_lua_get_module_name(L);
pnew = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pnew = new;
}
else {
new->re_pattern = g_strdup(string);
new->module = rspamd_lua_get_module_name(L);
pnew = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pnew = new;
}
}
}
else {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = old_start;
t->len = start - old_start;
t->flags = 0;
}
else {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = end;
t->len = (data + len) - end;
t->flags = 0;
"regexp_lua_pool", 0);
}
- rspamd_lua_new_class(L, "rspamd{regexp}", regexplib_m);
+ rspamd_lua_new_class(L, rspamd_regexp_classname, regexplib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_regexp", lua_load_regexp);
}
static RSA *
lua_check_rsa_pubkey(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{rsa_pubkey}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_rsa_pubkey_classname);
luaL_argcheck(L, ud != NULL, 1, "'rsa_pubkey' expected");
return ud ? *((RSA **) ud) : NULL;
static RSA *
lua_check_rsa_privkey(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{rsa_privkey}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_rsa_privkey_classname);
luaL_argcheck(L, ud != NULL, 1, "'rsa_privkey' expected");
return ud ? *((RSA **) ud) : NULL;
static rspamd_fstring_t *
lua_check_rsa_sign(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{rsa_signature}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_rsa_signature_classname);
luaL_argcheck(L, ud != NULL, 1, "'rsa_signature' expected");
return ud ? *((rspamd_fstring_t **) ud) : NULL;
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_pubkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_pubkey_classname, -1);
*prsa = rsa;
}
fclose(f);
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_pubkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_pubkey_classname, -1);
*prsa = rsa;
}
BIO_free(bp);
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_privkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_privkey_classname, -1);
*prsa = rsa;
}
fclose(f);
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_privkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_privkey_classname, -1);
*prsa = rsa;
}
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_privkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_privkey_classname, -1);
*prsa = rsa;
}
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_privkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_privkey_classname, -1);
*prsa = rsa;
}
}
else {
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_privkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_privkey_classname, -1);
*prsa = rsa;
}
BIO_free(bp);
else {
sig = rspamd_fstring_new_init(data, st.st_size);
psig = lua_newuserdata(L, sizeof(rspamd_fstring_t *));
- rspamd_lua_setclass(L, "rspamd{rsa_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_signature_classname, -1);
*psig = sig;
munmap(data, st.st_size);
}
if (data != NULL) {
sig = rspamd_fstring_new_init(data, dlen);
psig = lua_newuserdata(L, sizeof(rspamd_fstring_t *));
- rspamd_lua_setclass(L, "rspamd{rsa_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_signature_classname, -1);
*psig = sig;
}
else {
signature->len = siglen;
psig = lua_newuserdata(L, sizeof(rspamd_fstring_t *));
- rspamd_lua_setclass(L, "rspamd{rsa_signature}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_signature_classname, -1);
*psig = signature;
}
}
priv_rsa = RSAPrivateKey_dup(rsa);
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_privkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_privkey_classname, -1);
*prsa = priv_rsa;
pub_rsa = RSAPublicKey_dup(rsa);
prsa = lua_newuserdata(L, sizeof(RSA *));
- rspamd_lua_setclass(L, "rspamd{rsa_pubkey}", -1);
+ rspamd_lua_setclass(L, rspamd_rsa_pubkey_classname, -1);
*prsa = pub_rsa;
RSA_free(rsa);
void luaopen_rsa(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{rsa_pubkey}", rsapubkeylib_m);
+ rspamd_lua_new_class(L, rspamd_rsa_pubkey_classname, rsapubkeylib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_rsa_pubkey", lua_load_pubkey);
- rspamd_lua_new_class(L, "rspamd{rsa_privkey}", rsaprivkeylib_m);
+ rspamd_lua_new_class(L, rspamd_rsa_privkey_classname, rsaprivkeylib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_rsa_privkey", lua_load_privkey);
- rspamd_lua_new_class(L, "rspamd{rsa_signature}", rsasignlib_m);
+ rspamd_lua_new_class(L, rspamd_rsa_signature_classname, rsasignlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_rsa_signature", lua_load_signature);
#include "libserver/spf.h"
#include "libutil/ref.h"
-#define SPF_RECORD_CLASS "rspamd{spf_record}"
+#define SPF_RECORD_CLASS rspamd_spf_record_classname
LUA_FUNCTION_DEF(spf, resolve);
LUA_FUNCTION_DEF(spf, config);
static sqlite3 *
lua_check_sqlite3(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{sqlite3}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_sqlite3_classname);
luaL_argcheck(L, ud != NULL, pos, "'sqlite3' expected");
return ud ? *((sqlite3 **) ud) : NULL;
}
static sqlite3_stmt *
lua_check_sqlite3_stmt(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{sqlite3_stmt}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_sqlite3_stmt_classname);
luaL_argcheck(L, ud != NULL, pos, "'sqlite3_stmt' expected");
return ud ? *((sqlite3_stmt **) ud) : NULL;
}
pdb = lua_newuserdata(L, sizeof(db));
*pdb = db;
- rspamd_lua_setclass(L, "rspamd{sqlite3}", -1);
+ rspamd_lua_setclass(L, rspamd_sqlite3_classname, -1);
return 1;
}
/* Create C closure */
pstmt = lua_newuserdata(L, sizeof(stmt));
*pstmt = stmt;
- rspamd_lua_setclass(L, "rspamd{sqlite3_stmt}", -1);
+ rspamd_lua_setclass(L, rspamd_sqlite3_stmt_classname, -1);
lua_pushcclosure(L, lua_sqlite3_next_row, 1);
}
*/
void luaopen_sqlite3(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{sqlite3}", sqlitelib_m);
+ rspamd_lua_new_class(L, rspamd_sqlite3_classname, sqlitelib_m);
lua_pop(L, 1);
- rspamd_lua_new_class(L, "rspamd{sqlite3_stmt}", sqlitestmtlib_m);
+ rspamd_lua_new_class(L, rspamd_sqlite3_stmt_classname, sqlitestmtlib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_sqlite3", lua_load_sqlite3);
static struct rspamd_image *
lua_check_image(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{image}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_image_classname);
luaL_argcheck(L, ud != NULL, 1, "'image' expected");
return ud ? *((struct rspamd_image **) ud) : NULL;
}
static struct rspamd_archive *
lua_check_archive(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{archive}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_archive_classname);
luaL_argcheck(L, ud != NULL, 1, "'archive' expected");
return ud ? *((struct rspamd_archive **) ud) : NULL;
}
if (task) {
pcfg = lua_newuserdata(L, sizeof(gpointer));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = task->cfg;
}
else {
{
LUA_TRACE_POINT;
struct rspamd_task *task = lua_check_task(L, 1);
- void *ud = rspamd_lua_check_udata(L, 2, "rspamd{config}");
+ void *ud = rspamd_lua_check_udata(L, 2, rspamd_config_classname);
if (task) {
luaL_argcheck(L, ud != NULL, 1, "'config' expected");
if (task) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->flags = 0;
t->start = task->msg.begin;
t->len = task->msg.len;
if (lua_type(L, 2) == LUA_TUSERDATA) {
gpointer p;
- p = rspamd_lua_check_udata_maybe(L, 2, "rspamd{config}");
+ p = rspamd_lua_check_udata_maybe(L, 2, rspamd_config_classname);
if (p) {
cfg = *(struct rspamd_config **) p;
if (lua_type(L, 2) == LUA_TUSERDATA) {
gpointer p;
- p = rspamd_lua_check_udata_maybe(L, 2, "rspamd{config}");
+ p = rspamd_lua_check_udata_maybe(L, 2, rspamd_config_classname);
if (p) {
cfg = *(struct rspamd_config **) p;
if (lua_type(L, 1) == LUA_TUSERDATA) {
gpointer p;
- p = rspamd_lua_check_udata_maybe(L, 1, "rspamd{config}");
+ p = rspamd_lua_check_udata_maybe(L, 1, rspamd_config_classname);
if (p) {
cfg = *(struct rspamd_config **) p;
if (lua_type(L, 2) == LUA_TUSERDATA) {
gpointer p;
- p = rspamd_lua_check_udata_maybe(L, 2, "rspamd{ev_base}");
+ p = rspamd_lua_check_udata_maybe(L, 2, rspamd_ev_base_classname);
if (p) {
ev_base = *(struct ev_loop **) p;
if (task != NULL) {
ppool = lua_newuserdata(L, sizeof(rspamd_mempool_t *));
- rspamd_lua_setclass(L, "rspamd{mempool}", -1);
+ rspamd_lua_setclass(L, rspamd_mempool_classname, -1);
*ppool = task->task_pool;
}
else {
if (task != NULL) {
psession = lua_newuserdata(L, sizeof(void *));
- rspamd_lua_setclass(L, "rspamd{session}", -1);
+ rspamd_lua_setclass(L, rspamd_session_classname, -1);
*psession = task->s;
}
else {
if (task != NULL) {
pbase = lua_newuserdata(L, sizeof(struct ev_loop *));
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
*pbase = task->event_loop;
}
else {
if (task != NULL) {
if (task->worker) {
pworker = lua_newuserdata(L, sizeof(struct rspamd_worker *));
- rspamd_lua_setclass(L, "rspamd{worker}", -1);
+ rspamd_lua_setclass(L, rspamd_worker_classname, -1);
*pworker = task->worker;
}
else {
if (lua_isuserdata(L, 3)) {
/* We also have a mime part there */
mpart = *((struct rspamd_mime_part **) rspamd_lua_check_udata_maybe(L,
- 3, "rspamd{mimepart}"));
+ 3, rspamd_mimepart_classname));
}
if (task && task->message && url && url->url) {
if (task) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->len = task->msg.len;
t->start = task->msg.begin;
t->flags = 0;
{
ppart = lua_newuserdata(L, sizeof(struct rspamd_mime_text_part *));
*ppart = part;
- rspamd_lua_setclass(L, "rspamd{textpart}", -1);
+ rspamd_lua_setclass(L, rspamd_textpart_classname, -1);
/* Make it array */
lua_rawseti(L, -2, i + 1);
}
{
ppart = lua_newuserdata(L, sizeof(struct rspamd_mime_part *));
*ppart = part;
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
/* Make it array */
lua_rawseti(L, -2, i + 1);
}
if (hdr) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = hdr->begin;
t->len = hdr->len;
t->flags = 0;
if (task && task->message) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = MESSAGE_FIELD(task, raw_headers_content).begin;
t->len = MESSAGE_FIELD(task, raw_headers_content).len;
t->flags = 0;
if (task != NULL && task->resolver != NULL) {
presolver = lua_newuserdata(L, sizeof(void *));
- rspamd_lua_setclass(L, "rspamd{resolver}", -1);
+ rspamd_lua_setclass(L, rspamd_resolver_classname, -1);
*presolver = task->resolver;
}
else {
{
if (part->part_type == RSPAMD_MIME_PART_IMAGE) {
pimg = lua_newuserdata(L, sizeof(struct rspamd_image *));
- rspamd_lua_setclass(L, "rspamd{image}", -1);
+ rspamd_lua_setclass(L, rspamd_image_classname, -1);
*pimg = part->specific.img;
lua_rawseti(L, -2, ++nelt);
}
{
if (part->part_type == RSPAMD_MIME_PART_ARCHIVE) {
parch = lua_newuserdata(L, sizeof(struct rspamd_archive *));
- rspamd_lua_setclass(L, "rspamd{archive}", -1);
+ rspamd_lua_setclass(L, rspamd_archive_classname, -1);
*parch = part->specific.arch;
lua_rawseti(L, -2, ++nelt);
}
lua_gettable(L, 3);
if (lua_isuserdata(L, -1)) {
- RSPAMD_LUA_CHECK_UDATA_PTR_OR_RETURN(L, -1, "rspamd{regexp}",
+ RSPAMD_LUA_CHECK_UDATA_PTR_OR_RETURN(L, -1, rspamd_regexp_classname,
struct rspamd_lua_regexp, re);
}
static void
luaopen_archive(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{archive}", archivelib_m);
+ rspamd_lua_new_class(L, rspamd_archive_classname, archivelib_m);
lua_pop(L, 1);
}
void luaopen_image(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{image}", imagelib_m);
+ rspamd_lua_new_class(L, rspamd_image_classname, imagelib_m);
lua_pop(L, 1);
}
static struct lua_tcp_cbdata *
lua_check_tcp(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{tcp}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_tcp_classname);
luaL_argcheck(L, ud != NULL, pos, "'tcp' expected");
return ud ? *((struct lua_tcp_cbdata **) ud) : NULL;
}
/* Connection */
pcbd = lua_newuserdata(L, sizeof(*pcbd));
*pcbd = cbd;
- rspamd_lua_setclass(L, "rspamd{tcp}", -1);
+ rspamd_lua_setclass(L, rspamd_tcp_classname, -1);
TCP_RETAIN(cbd);
if (cbd->item) {
if (hdl->type == LUA_WANT_READ) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = (const gchar *) str;
t->len = len;
t->flags = 0;
/* Connection */
pcbd = lua_newuserdata(L, sizeof(*pcbd));
*pcbd = cbd;
- rspamd_lua_setclass(L, "rspamd{tcp}", -1);
+ rspamd_lua_setclass(L, rspamd_tcp_classname, -1);
TCP_RETAIN(cbd);
lua_thread_pool_set_running_entry(cbd->cfg->lua_thread_pool, cbd->thread);
pcbd = lua_newuserdata(L, sizeof(*pcbd));
*pcbd = cbd;
- rspamd_lua_setclass(L, "rspamd{tcp_sync}", -1);
+ rspamd_lua_setclass(L, rspamd_tcp_sync_classname, -1);
msg_debug_tcp("tcp connected");
lua_tcp_shift_handler(cbd);
pcbd = lua_newuserdata(L, sizeof(*pcbd));
*pcbd = cbd;
TCP_RETAIN(cbd);
- rspamd_lua_setclass(L, "rspamd{tcp}", -1);
+ rspamd_lua_setclass(L, rspamd_tcp_classname, -1);
if (cbd->item) {
rspamd_symcache_set_cur_item(cbd->task, cbd->item);
if (task == NULL) {
lua_pushstring(L, "ev_base");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{ev_base}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_ev_base_classname)) {
event_loop = *(struct ev_loop **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "session");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{session}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_session_classname)) {
session = *(struct rspamd_async_session **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "config");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{config}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_config_classname)) {
cfg = *(struct rspamd_config **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "resolver");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{resolver}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_resolver_classname)) {
resolver = *(struct rspamd_dns_resolver **) lua_touserdata(L, -1);
}
else {
static struct lua_tcp_cbdata *
lua_check_sync_tcp(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{tcp_sync}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_tcp_sync_classname);
luaL_argcheck(L, ud != NULL, pos, "'tcp' expected");
return ud ? *((struct lua_tcp_cbdata **) ud) : NULL;
}
void luaopen_tcp(lua_State *L)
{
rspamd_lua_add_preload(L, "rspamd_tcp", lua_load_tcp);
- rspamd_lua_new_class(L, "rspamd{tcp}", tcp_libm);
- rspamd_lua_new_class(L, "rspamd{tcp_sync}", tcp_sync_libm);
+ rspamd_lua_new_class(L, rspamd_tcp_classname, tcp_libm);
+ rspamd_lua_new_class(L, rspamd_tcp_sync_classname, tcp_sync_libm);
lua_pop(L, 1);
}
struct rspamd_lua_text *
lua_check_text(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{text}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_text_classname);
luaL_argcheck(L, ud != NULL, pos, "'text' expected");
return ud ? (struct rspamd_lua_text *) ud : NULL;
}
gint pos_type = lua_type(L, pos);
if (pos_type == LUA_TUSERDATA) {
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{text}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_text_classname);
luaL_argcheck(L, ud != NULL, pos, "'text' expected");
return ud ? (struct rspamd_lua_text *) ud : NULL;
}
}
t->len = len;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
return t;
}
}
t->len = len;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
return t;
}
t->start = dest;
t->len = textlen;
t->flags = RSPAMD_TEXT_FLAG_OWN;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
lua_pushvalue(L, 1);
lua_text_tbl_append(L, delim, dlen, &dest, 0);
struct rspamd_lua_text *ntext;
ntext = lua_newuserdata(L, sizeof(*ntext));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
ntext->start = start;
ntext->len = len;
ntext->flags = 0; /* Not own as it must be owned by a top object */
}
else {
new_t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
new_t->start = old_start;
new_t->len = start - old_start;
new_t->flags = 0;
}
else {
new_t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
new_t->start = end;
new_t->len = (t->start + t->len) - end;
new_t->flags = 0;
if (own_re) {
struct rspamd_lua_regexp **pre;
pre = lua_newuserdata(L, sizeof(struct rspamd_lua_regexp *));
- rspamd_lua_setclass(L, "rspamd{regexp}", -1);
+ rspamd_lua_setclass(L, rspamd_regexp_classname, -1);
*pre = re;
}
else {
out->start = rspamd_encode_base64_common(t->start, t->len,
line_len, &sz_len, fold, how);
out->len = sz_len;
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
}
else {
return luaL_error(L, "invalid arguments");
dest = g_malloc(t->len);
nt = lua_newuserdata(L, sizeof(*nt));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
nt->len = t->len;
nt->flags = RSPAMD_TEXT_FLAG_OWN;
memcpy(dest, t->start, t->len);
dest = g_malloc(t->len);
nt = lua_newuserdata(L, sizeof(*nt));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
nt->len = t->len;
nt->flags = RSPAMD_TEXT_FLAG_OWN;
memcpy(dest, t->start, t->len);
void luaopen_text(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{text}", textlib_m);
+ rspamd_lua_new_class(L, rspamd_text_classname, textlib_m);
lua_pushstring(L, "cookie");
lua_pushnumber(L, rspamd_lua_text_cookie);
lua_settable(L, -3);
static struct rspamd_multipattern *
lua_check_trie(lua_State *L, gint idx)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{trie}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_trie_classname);
luaL_argcheck(L, ud != NULL, 1, "'trie' expected");
return ud ? *((struct rspamd_multipattern **) ud) : NULL;
}
else {
ptrie = lua_newuserdata(L, sizeof(void *));
- rspamd_lua_setclass(L, "rspamd{trie}", -1);
+ rspamd_lua_setclass(L, rspamd_trie_classname, -1);
*ptrie = trie;
}
}
void luaopen_trie(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{trie}", trielib_m);
+ rspamd_lua_new_class(L, rspamd_trie_classname, trielib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_trie", lua_load_trie);
}
if (task == NULL) {
lua_pushstring(L, "ev_base");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{ev_base}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_ev_base_classname)) {
ev_base = *(struct ev_loop **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "session");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{session}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_session_classname)) {
session = *(struct rspamd_async_session **) lua_touserdata(L, -1);
}
else {
lua_pushstring(L, "pool");
lua_gettable(L, -2);
- if (rspamd_lua_check_udata_maybe(L, -1, "rspamd{mempool}")) {
+ if (rspamd_lua_check_udata_maybe(L, -1, rspamd_mempool_classname)) {
pool = *(rspamd_mempool_t **) lua_touserdata(L, -1);
}
else {
struct rspamd_lua_upstream *
lua_check_upstream(lua_State *L, int pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{upstream}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_upstream_classname);
luaL_argcheck(L, ud != NULL, 1, "'upstream' expected");
return ud ? (struct rspamd_lua_upstream *) ud : NULL;
static struct upstream_list *
lua_check_upstream_list(lua_State *L)
{
- void *ud = rspamd_lua_check_udata(L, 1, "rspamd{upstream_list}");
+ void *ud = rspamd_lua_check_udata(L, 1, rspamd_upstream_list_classname);
luaL_argcheck(L, ud != NULL, 1, "'upstream_list' expected");
return ud ? *((struct upstream_list **) ud) : NULL;
lua_ups = lua_newuserdata(L, sizeof(*lua_ups));
lua_ups->up = up;
- rspamd_lua_setclass(L, "rspamd{upstream}", -1);
+ rspamd_lua_setclass(L, rspamd_upstream_classname, -1);
/* Store parent in the upstream to prevent gc */
lua_pushvalue(L, up_idx);
lua_ups->upref = luaL_ref(L, LUA_REGISTRYINDEX);
if (rspamd_upstreams_parse_line(new, def, default_port, NULL)) {
pnew = lua_newuserdata(L, sizeof(struct upstream_list *));
- rspamd_lua_setclass(L, "rspamd{upstream_list}", -1);
+ rspamd_lua_setclass(L, rspamd_upstream_list_classname, -1);
*pnew = new;
}
else {
else if (lua_type(L, top) == LUA_TTABLE) {
new = rspamd_upstreams_create(cfg ? cfg->ups_ctx : NULL);
pnew = lua_newuserdata(L, sizeof(struct upstream_list *));
- rspamd_lua_setclass(L, "rspamd{upstream_list}", -1);
+ rspamd_lua_setclass(L, rspamd_upstream_list_classname, -1);
*pnew = new;
lua_pushvalue(L, top);
struct rspamd_lua_upstream *lua_ups = lua_newuserdata(L, sizeof(*lua_ups));
lua_ups->up = up;
- rspamd_lua_setclass(L, "rspamd{upstream}", -1);
+ rspamd_lua_setclass(L, rspamd_upstream_classname, -1);
/* Store parent in the upstream to prevent gc */
lua_rawgeti(L, LUA_REGISTRYINDEX, cdata->parent_cbref);
lua_ups->upref = luaL_ref(L, LUA_REGISTRYINDEX);
void luaopen_upstream(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{upstream_list}", upstream_list_m);
+ rspamd_lua_new_class(L, rspamd_upstream_list_classname, upstream_list_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_upstream_list", lua_load_upstream_list);
- rspamd_lua_new_class(L, "rspamd{upstream}", upstream_m);
+ rspamd_lua_new_class(L, rspamd_upstream_classname, upstream_m);
lua_pop(L, 1);
}
struct rspamd_lua_url *
lua_check_url(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{url}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_url_classname);
luaL_argcheck(L, ud != NULL, pos, "'url' expected");
return ud ? ((struct rspamd_lua_url *) ud) : NULL;
}
struct rspamd_lua_url *lua_url;
lua_url = lua_newuserdata(L, sizeof(struct rspamd_lua_url));
- rspamd_lua_setclass(L, "rspamd{url}", -1);
+ rspamd_lua_setclass(L, rspamd_url_classname, -1);
lua_url->url = url;
return TRUE;
if (url->url->flags &
(RSPAMD_URL_FLAG_PHISHED | RSPAMD_URL_FLAG_REDIRECTED)) {
purl = lua_newuserdata(L, sizeof(struct rspamd_lua_url));
- rspamd_lua_setclass(L, "rspamd{url}", -1);
+ rspamd_lua_setclass(L, rspamd_url_classname, -1);
purl->url = url->url->ext->linked_url;
return 1;
n = rspamd_lua_table_size(L, -1);
lua_url = lua_newuserdata(L, sizeof(struct rspamd_lua_url));
- rspamd_lua_setclass(L, "rspamd{url}", -1);
+ rspamd_lua_setclass(L, rspamd_url_classname, -1);
lua_url->url = url;
lua_rawseti(L, -2, n + 1);
cbd->flags_mask = flags_mask;
/* This needs to be removed from the stack */
- rspamd_lua_class_metatable(L, "rspamd{url}");
+ rspamd_lua_class_metatable(L, rspamd_url_classname);
cbd->metatable_pos = lua_gettop(L);
(void) lua_checkstack(L, cbd->metatable_pos + 4);
cbd->flags_exclude_mask = exclude_flags_mask;
/* This needs to be removed from the stack */
- rspamd_lua_class_metatable(L, "rspamd{url}");
+ rspamd_lua_class_metatable(L, rspamd_url_classname);
cbd->metatable_pos = lua_gettop(L);
(void) lua_checkstack(L, cbd->metatable_pos + 4);
void luaopen_url(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{url}", urllib_m);
+ rspamd_lua_new_class(L, rspamd_url_classname, urllib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_url", lua_load_url);
static gint64
lua_check_int64(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{int64}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_int64_classname);
luaL_argcheck(L, ud != NULL, pos, "'int64' expected");
return ud ? *((gint64 *) ud) : 0LL;
}
struct ev_loop **pev_base;
pev_base = lua_newuserdata(L, sizeof(struct ev_loop *));
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
*pev_base = ev_loop_new(EVFLAG_SIGNALFD | EVBACKEND_ALL);
return 1;
else {
rspamd_config_post_load(cfg, 0);
pcfg = lua_newuserdata(L, sizeof(struct rspamd_config *));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = cfg;
}
}
rspamd_config_post_load(cfg, int_options);
pcfg = lua_newuserdata(L, sizeof(struct rspamd_config *));
- rspamd_lua_setclass(L, "rspamd{config}", -1);
+ rspamd_lua_setclass(L, rspamd_config_classname, -1);
*pcfg = cfg;
}
if (out != NULL) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = out;
t->len = outlen;
/* Need destruction */
}
else {
out = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
out->start = g_malloc(inlen + 1);
out->flags = RSPAMD_TEXT_FLAG_OWN;
outlen = rspamd_decode_qp_buf(s, inlen, (gchar *) out->start, inlen + 1);
if (s != NULL) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->len = (inlen / 4) * 3 + 3;
t->start = g_malloc(t->len);
if (out != NULL) {
t = lua_newuserdata(L, sizeof(*t));
outlen = strlen(out);
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = out;
t->len = outlen;
/* Need destruction */
if (decoded) {
t = lua_newuserdata(L, sizeof(*t));
- rspamd_lua_setclass(L, "rspamd{text}", -1);
+ rspamd_lua_setclass(L, rspamd_text_classname, -1);
t->start = (const gchar *) decoded;
t->len = outlen;
t->flags = RSPAMD_TEXT_FLAG_OWN;
h = rspamd_icase_hash(t->start, t->len, seed);
r = lua_newuserdata(L, sizeof(*r));
*r = h;
- rspamd_lua_setclass(L, "rspamd{int64}", -1);
+ rspamd_lua_setclass(L, rspamd_int64_classname, -1);
return 1;
}
void luaopen_util(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{ev_base}", ev_baselib_m);
+ rspamd_lua_new_class(L, rspamd_ev_base_classname, ev_baselib_m);
lua_pop(L, 1);
- rspamd_lua_new_class(L, "rspamd{int64}", int64lib_m);
+ rspamd_lua_new_class(L, rspamd_int64_classname, int64lib_m);
lua_pop(L, 1);
rspamd_lua_add_preload(L, "rspamd_util", lua_load_util);
rspamd_lua_add_preload(L, "rspamd_int64", lua_load_int64);
}
gint64 *i64_p = lua_newuserdata(L, sizeof(gint64));
- rspamd_lua_setclass(L, "rspamd{int64}", -1);
+ rspamd_lua_setclass(L, rspamd_int64_classname, -1);
memcpy(i64_p, &u64, sizeof(u64));
if (neg) {
static struct rspamd_worker *
lua_check_worker(lua_State *L, gint pos)
{
- void *ud = rspamd_lua_check_udata(L, pos, "rspamd{worker}");
+ void *ud = rspamd_lua_check_udata(L, pos, rspamd_worker_classname);
luaL_argcheck(L, ud != NULL, pos, "'worker' expected");
return ud ? *((struct rspamd_worker **) ud) : NULL;
}
err_idx = lua_gettop(L);
lua_rawgeti(L, LUA_REGISTRYINDEX, cbd->cbref);
psession = lua_newuserdata(L, sizeof(*psession));
- rspamd_lua_setclass(L, "rspamd{session}", -1);
+ rspamd_lua_setclass(L, rspamd_session_classname, -1);
*psession = session;
/* Command name */
void luaopen_worker(lua_State *L)
{
- rspamd_lua_new_class(L, "rspamd{worker}", worker_reg);
+ rspamd_lua_new_class(L, rspamd_worker_classname, worker_reg);
}
ppart = lua_newuserdata(L, sizeof(*ppart));
*ppart = part;
- rspamd_lua_setclass(L, "rspamd{mimepart}", -1);
+ rspamd_lua_setclass(L, rspamd_mimepart_classname, -1);
lua_pushnumber(L, rule->lua_id);
NULL, (event_finalizer_t) NULL, NULL);
psession = lua_newuserdata(L, sizeof(struct rspamd_async_session *));
- rspamd_lua_setclass(L, "rspamd{session}", -1);
+ rspamd_lua_setclass(L, rspamd_session_classname, -1);
*psession = rspamadm_session;
lua_setglobal(L, "rspamadm_session");
pev_base = lua_newuserdata(L, sizeof(struct ev_loop *));
- rspamd_lua_setclass(L, "rspamd{ev_base}", -1);
+ rspamd_lua_setclass(L, rspamd_ev_base_classname, -1);
*pev_base = rspamd_main->event_loop;
lua_setglobal(L, "rspamadm_ev_base");
presolver = lua_newuserdata(L, sizeof(struct rspamd_dns_resolver *));
- rspamd_lua_setclass(L, "rspamd{resolver}", -1);
+ rspamd_lua_setclass(L, rspamd_resolver_classname, -1);
*presolver = resolver;
lua_setglobal(L, "rspamadm_dns_resolver");
}
projects / thirdparty / rspamd.git / commitdiff
