void
free_smtp_session (gpointer arg)
{
struct smtp_session *session = arg;
if (session) {
if (session->task) {
rspamd_task_free (session->task, FALSE);
if (session->task->msg.start) {
munmap (session->task->msg.start, session->task->msg.len);
}
}
if (session->rcpt) {
g_list_free (session->rcpt);
}
if (session->dispatcher) {
rspamd_remove_dispatcher (session->dispatcher);
}
close (session->sock);
if (session->temp_name != NULL) {
unlink (session->temp_name);
}
if (session->temp_fd != -1) {
close (session->temp_fd);
}
rspamd_mempool_delete (session->pool);
g_free (session);
}
}
gint
dkim_module_reconfig (struct rspamd_config *cfg)
{
struct module_ctx saved_ctx;
saved_ctx = dkim_module_ctx->ctx;
rspamd_mempool_delete (dkim_module_ctx->dkim_pool);
radix_destroy_compressed (dkim_module_ctx->whitelist_ip);
if (dkim_module_ctx->dkim_domains) {
g_hash_table_destroy (dkim_module_ctx->dkim_domains);
}
memset (dkim_module_ctx, 0, sizeof (*dkim_module_ctx));
dkim_module_ctx->ctx = saved_ctx;
dkim_module_ctx->dkim_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "dkim");
dkim_module_ctx->sign_headers = "from:sender:reply-to:subject:date:message-id:"
"to:cc:mime-version:content-type:content-transfer-encoding:"
"resent-to:resent-cc:resent-from:resent-sender:resent-message-id:"
"in-reply-to:references:list-id:list-owner:list-unsubscribe:"
"list-subscribe:list-post";
dkim_module_ctx->sign_condition_ref = -1;
dkim_module_ctx->max_sigs = DEFAULT_MAX_SIGS;
return dkim_module_config (cfg);
}
void
rspamd_config_free (struct rspamd_config *cfg)
{
rspamd_map_remove_all (cfg);
ucl_obj_unref (cfg->rcl_obj);
g_hash_table_remove_all (cfg->metrics);
g_hash_table_unref (cfg->metrics);
g_hash_table_unref (cfg->c_modules);
g_hash_table_remove_all (cfg->composite_symbols);
g_hash_table_unref (cfg->composite_symbols);
g_hash_table_remove_all (cfg->cfg_params);
g_hash_table_unref (cfg->cfg_params);
g_hash_table_destroy (cfg->metrics_symbols);
g_hash_table_unref (cfg->classifiers_symbols);
g_hash_table_unref (cfg->debug_modules);
g_hash_table_unref (cfg->explicit_modules);
if (cfg->checksum) {
g_free (cfg->checksum);
}
g_list_free (cfg->classifiers);
g_list_free (cfg->metrics_list);
rspamd_mempool_delete (cfg->cfg_pool);
}
gint
chartable_module_reconfig (struct rspamd_config *cfg)
{
rspamd_mempool_delete (chartable_module_ctx->chartable_pool);
chartable_module_ctx->chartable_pool = rspamd_mempool_new (1024);
return chartable_module_config (cfg);
}
void
radix_destroy_compressed (radix_compressed_t *tree)
{
if (tree) {
rspamd_mempool_delete (tree->pool);
g_slice_free1 (sizeof (*tree), tree);
}
}
void
rspamd_map_remove_all (struct rspamd_config *cfg)
{
g_list_free (cfg->maps);
cfg->maps = NULL;
if (cfg->map_pool != NULL) {
rspamd_mempool_delete (cfg->map_pool);
cfg->map_pool = NULL;
}
}
/***
* @function url.create([mempool,] str)
* @param {rspamd_mempool} memory pool for URL, e.g. `task:get_mempool()`
* @param {string} text that contains URL (can also contain other stuff)
* @return {url} new url object that exists as long as the corresponding mempool exists
*/
static gint
lua_url_create (lua_State *L)
{
rspamd_mempool_t *pool;
const gchar *text;
size_t length;
gboolean own_pool = FALSE;
if (lua_type (L, 1) == LUA_TUSERDATA) {
pool = rspamd_lua_check_mempool (L, 1);
text = luaL_checklstring (L, 2, &length);
}
else {
own_pool = TRUE;
pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "url");
text = luaL_checklstring (L, 1, &length);
}
if (pool == NULL || text == NULL) {
if (own_pool && pool) {
rspamd_mempool_delete (pool);
}
return luaL_error (L, "invalid arguments");
}
else {
rspamd_url_find_single (pool, text, length, FALSE,
lua_url_single_inserter, L);
if (lua_type (L, -1) != LUA_TUSERDATA) {
/* URL is actually not found */
lua_pushnil (L);
}
}
if (own_pool && pool) {
rspamd_mempool_delete (pool);
}
return 1;
}
void
rspamd_symbols_cache_destroy (struct symbols_cache *cache)
{
GList *cur;
struct delayed_cache_dependency *ddep;
struct delayed_cache_condition *dcond;
if (cache != NULL) {
if (cache->cfg->cache_filename) {
/* Try to sync values to the disk */
if (!rspamd_symbols_cache_save_items (cache,
cache->cfg->cache_filename)) {
msg_err_cache ("cannot save cache data to %s",
cache->cfg->cache_filename);
}
}
if (cache->delayed_deps) {
cur = cache->delayed_deps;
while (cur) {
ddep = cur->data;
g_free (ddep->from);
g_free (ddep->to);
g_slice_free1 (sizeof (*ddep), ddep);
cur = g_list_next (cur);
}
g_list_free (cache->delayed_deps);
}
if (cache->delayed_conditions) {
cur = cache->delayed_conditions;
while (cur) {
dcond = cur->data;
g_free (dcond->sym);
g_slice_free1 (sizeof (*dcond), dcond);
cur = g_list_next (cur);
}
g_list_free (cache->delayed_conditions);
}
g_hash_table_destroy (cache->items_by_symbol);
rspamd_mempool_delete (cache->static_pool);
g_ptr_array_free (cache->items_by_id, TRUE);
REF_RELEASE (cache->items_by_order);
g_slice_free1 (sizeof (*cache), cache);
}
}
gint
regexp_module_reconfig (struct rspamd_config *cfg)
{
struct module_ctx saved_ctx;
saved_ctx = regexp_module_ctx->ctx;
rspamd_mempool_delete (regexp_module_ctx->regexp_pool);
memset (regexp_module_ctx, 0, sizeof (*regexp_module_ctx));
regexp_module_ctx->ctx = saved_ctx;
regexp_module_ctx->regexp_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
return regexp_module_config (cfg);
}
gint
dkim_module_reconfig (struct rspamd_config *cfg)
{
rspamd_mempool_delete (dkim_module_ctx->dkim_pool);
radix_destroy_compressed (dkim_module_ctx->whitelist_ip);
if (dkim_module_ctx->dkim_domains) {
g_hash_table_destroy (dkim_module_ctx->dkim_domains);
}
memset (dkim_module_ctx, 0, sizeof (*dkim_module_ctx));
dkim_module_ctx->dkim_pool = rspamd_mempool_new (
rspamd_mempool_suggest_size ());
return dkim_module_config (cfg);
}
void
rspamd_fuzzy_test_func ()
{
rspamd_mempool_t *pool;
rspamd_fuzzy_t *h1, *h2, *h3, *h4, *h5;
rspamd_fstring_t f1, f2, f3, f4, f5;
int diff2;
pool = rspamd_mempool_new (1024);
f1.begin = s1;
f1.len = strlen (s1);
f2.begin = s2;
f2.len = strlen (s2);
f3.begin = s3;
f3.len = strlen (s3);
f4.begin = s4;
f4.len = strlen (s4);
f5.begin = s5;
f5.len = strlen (s5);
h1 = rspamd_fuzzy_init (&f1, pool);
h2 = rspamd_fuzzy_init (&f2, pool);
h3 = rspamd_fuzzy_init (&f3, pool);
h4 = rspamd_fuzzy_init (&f4, pool);
h5 = rspamd_fuzzy_init (&f5, pool);
diff2 = rspamd_fuzzy_compare (h2, h5);
msg_debug ("rspamd_fuzzy_test_func: s1, s2 difference between strings is %d", rspamd_fuzzy_compare (h1, h2));
msg_debug ("rspamd_fuzzy_test_func: s1, s3 difference between strings is %d", rspamd_fuzzy_compare (h1, h3));
msg_debug ("rspamd_fuzzy_test_func: s3, s4 difference between strings is %d", rspamd_fuzzy_compare (h3, h4));
msg_debug ("rspamd_fuzzy_test_func: s2, s4 difference between strings is %d", rspamd_fuzzy_compare (h2, h4));
msg_debug ("rspamd_fuzzy_test_func: s2, s5 difference between strings is %d", diff2);
/* Identical strings */
if (diff2 != 100) {
msg_err ("hash difference is %d", diff2);
g_assert (diff2 == 100);
}
rspamd_mempool_delete (pool);
}
void
rspamd_map_remove_all (struct rspamd_config *cfg)
{
struct rspamd_map *map;
GList *cur;
for (cur = cfg->maps; cur != NULL; cur = g_list_next (cur)) {
map = cur->data;
if (map->dtor) {
map->dtor (map->dtor_data);
}
}
g_list_free (cfg->maps);
cfg->maps = NULL;
if (cfg->map_pool != NULL) {
rspamd_mempool_delete (cfg->map_pool);
cfg->map_pool = NULL;
}
}
static void
rspamd_process_file (const gchar *fname)
{
struct rspamd_task *task;
GIOChannel *f;
GError *err = NULL;
GString *buf;
struct received_header rh;
gdouble t1, t2;
f = g_io_channel_new_file (fname, "r", &err);
if (!f) {
rspamd_fprintf (stderr, "cannot open %s: %e\n", fname, err);
g_error_free (err);
return;
}
g_io_channel_set_encoding (f, NULL, NULL);
buf = g_string_sized_new (8192);
task = g_malloc0 (sizeof (*task));
task->task_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "test");
while (g_io_channel_read_line_string (f, buf, NULL, &err)
== G_IO_STATUS_NORMAL) {
while (buf->len > 0 && g_ascii_isspace (buf->str[buf->len - 1])) {
buf->len --;
}
t1 = rspamd_get_virtual_ticks ();
rspamd_smtp_recieved_parse (task, buf->str, buf->len, &rh);
t2 = rspamd_get_virtual_ticks ();
total_time += t2 - t1;
total_parsed ++;
if (rh.addr) {
total_real_ip ++;
}
if (rh.real_hostname) {
total_real_host ++;
}
if (rh.type != RSPAMD_RECEIVED_UNKNOWN) {
total_known_proto ++;
}
if (rh.by_hostname || rh.timestamp > 0) {
total_valid ++;
}
if (rh.timestamp != 0) {
total_known_ts ++;
}
}
if (err) {
rspamd_fprintf (stderr, "cannot read %s: %e\n", fname, err);
g_error_free (err);
}
g_io_channel_unref (f);
g_string_free (buf, TRUE);
rspamd_mempool_delete (task->task_pool);
g_free (task);
}
/*
* Free all structures of worker_task
*/
void
rspamd_task_free (struct rspamd_task *task, gboolean is_soft)
{
struct mime_part *p;
struct mime_text_part *tp;
guint i;
if (task) {
debug_task ("free pointer %p", task);
for (i = 0; i < task->parts->len; i ++) {
p = g_ptr_array_index (task->parts, i);
g_byte_array_free (p->content, TRUE);
}
for (i = 0; i < task->text_parts->len; i ++) {
tp = g_ptr_array_index (task->text_parts, i);
if (tp->words) {
g_array_free (tp->words, TRUE);
}
if (tp->normalized_words) {
g_array_free (tp->normalized_words, TRUE);
}
}
if (task->images) {
g_list_free (task->images);
}
if (task->messages) {
g_list_free (task->messages);
}
if (task->http_conn != NULL) {
rspamd_http_connection_unref (task->http_conn);
}
if (task->sock != -1) {
close (task->sock);
}
if (task->settings != NULL) {
ucl_object_unref (task->settings);
}
if (task->client_addr) {
rspamd_inet_address_destroy (task->client_addr);
}
if (task->from_addr) {
rspamd_inet_address_destroy (task->from_addr);
}
if (task->err) {
g_error_free (task->err);
}
rspamd_mempool_delete (task->task_pool);
g_slice_free1 (sizeof (struct rspamd_task), task);
}
}
