#define DEFAULT_THRESHOLD 0.1

struct chartable_ctx {

double threshold;

memory_pool_t *chartable_pool;

static struct chartable_ctx *chartable_module_ctx = NULL;

static void chartable_symbol_callback (struct worker_task *task, void *unused);

chartable_module_init (struct config_file *cfg, struct module_ctx **ctx)

{

chartable_module_ctx = g_malloc (sizeof (struct chartable_ctx));

}

chartable_module_config (struct config_file *cfg)

{

if ((value = get_module_opt (cfg, "chartable", "symbol")) != NULL) {

chartable_module_ctx->symbol = memory_pool_strdup (chartable_module_ctx->chartable_pool, value);

return res;

}

chartable_module_reconfig (struct config_file *cfg)

{

memory_pool_delete (chartable_module_ctx->chartable_pool);

static gboolean

check_part (struct mime_text_part *part, gboolean raw_mode)

{

gunichar c, t;

GUnicodeScript scc, sct;

p = part->content->data;

}

chartable_mime_filter (struct worker_task *task)

{

/* XXX: remove it */

#define DEFAULT_SYMBOL "R_BAD_EMAIL"

"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\\b";

struct email_ctx {

GRegex *email_re;

GHashTable *blacklist;

memory_pool_t *email_pool;

};

static struct email_ctx *email_module_ctx = NULL;

static void emails_symbol_callback (struct worker_task *task, void *unused);

emails_module_init (struct config_file *cfg, struct module_ctx **ctx)

{

GError *err = NULL;

}

emails_module_config (struct config_file *cfg)

{

if ((value = get_module_opt (cfg, "emails", "symbol")) != NULL) {

email_module_ctx->symbol = memory_pool_strdup (email_module_ctx->email_pool, value);

return res;

}

emails_module_reconfig (struct config_file *cfg)

{

memory_pool_delete (email_module_ctx->email_pool);

GMatchInfo *info;

GError *err = NULL;

struct mime_text_part *part;

cur = g_list_first (task->text_parts);

while (cur) {

continue;

}

if (rc) {

while (g_match_info_matches (info)) {

email_str = g_match_info_fetch (info, 0);

return res;

}

emails_command_handler (struct worker_task *task)

{

GList *emails, *cur;

emails = extract_emails (task);

while (cur) {

num++;

if (g_list_next (cur) != NULL) {

}

else {

}

cur = g_list_next (cur);

}

while (cur) {

if (g_hash_table_lookup (email_module_ctx->blacklist, cur->data) != NULL) {

}

cur = g_list_next (cur);

}

emails_mime_filter (struct worker_task *task)

{

/* XXX: remove this */

struct storage_server {

struct upstream up;

struct in_addr addr;

};

struct fuzzy_mapping {

double weight;

};

struct fuzzy_mime_type {

};

struct fuzzy_ctx {

struct storage_server *servers;

memory_pool_t *fuzzy_pool;

double max_score;

gint32 min_hash_len;

};

struct fuzzy_client_session {

fuzzy_hash_t *h;

struct event ev;

struct timeval tv;

struct worker_task *task;

struct storage_server *server;

};

struct fuzzy_learn_session {

struct event ev;

fuzzy_hash_t *h;

struct timeval tv;

struct controller_session *session;

struct storage_server *server;

struct worker_task *task;

};

static struct fuzzy_ctx *fuzzy_module_ctx = NULL;

static const gchar hex_digits[] = "0123456789abcdef";

static void fuzzy_symbol_callback (struct worker_task *task, void *unused);

/* Flags string is in format <numeric_flag>:<SYMBOL>:weight[, <numeric_flag>:<SYMBOL>:weight...] */

static void

{

struct fuzzy_mapping *map;

strvec = g_strsplit_set (str, ", ;", 0);

}

static GList *

{

struct fuzzy_mime_type *type;

GList *res = NULL;

}

static void

{

struct hostent *hent;

struct in_addr addr;

}

static double

{

double ms = weight, ams = fabs (ms), ain = fabs (in);

return (double)in;

}

fuzzy_to_string (fuzzy_hash_t *h)

{

guint8 byte;

for (i = 0; i < FUZZY_HASHLEN; i ++) {

return strbuf;

}

fuzzy_check_module_init (struct config_file *cfg, struct module_ctx **ctx)

{

fuzzy_module_ctx = g_malloc0 (sizeof (struct fuzzy_ctx));

return 0;

}

fuzzy_check_module_config (struct config_file *cfg)

{

if ((value = get_module_opt (cfg, "fuzzy_check", "symbol")) != NULL) {

fuzzy_module_ctx->symbol = memory_pool_strdup (fuzzy_module_ctx->fuzzy_pool, value);

return res;

}

fuzzy_check_module_reconfig (struct config_file *cfg)

{

memory_pool_delete (fuzzy_module_ctx->fuzzy_pool);

/* Call this whenever we got data from fuzzy storage */

static void

{

struct fuzzy_client_session *session = arg;

struct fuzzy_cmd cmd;

struct fuzzy_mapping *map;

double nval;

if (what == EV_WRITE) {

}

static void

{

struct fuzzy_learn_session *session = arg;

struct fuzzy_cmd cmd;

if (what == EV_WRITE) {

/* Send command to storage */

{

struct fuzzy_client_session *session;

struct storage_server *selected;

/* Get upstream */

#ifdef HAVE_CLOCK_GETTIME

struct mime_text_part *part;

struct mime_part *mime_part;

struct rspamd_image *image;

GList *cur;

fuzzy_hash_t *fake_fuzzy;

/* Check whitelist */

if (fuzzy_module_ctx->whitelist && task->from_addr.s_addr != 0) {

msg_info ("<%s>, address %s is whitelisted, skip fuzzy check",

task->message_id, inet_ntoa (task->from_addr));

return;

G_INLINE_FUNC gboolean

register_fuzzy_controller_call (struct controller_session *session, struct worker_task *task, fuzzy_hash_t *h,

{

struct fuzzy_learn_session *s;

struct storage_server *selected;

/* Get upstream */

#ifdef HAVE_CLOCK_GETTIME

struct mime_part *mime_part;

struct rspamd_image *image;

GList *cur;

fuzzy_hash_t fake_fuzzy;

/* Extract arguments */

task->msg->len = in->len;

r = process_message (task);

if (r == -1) {

msg_warn ("processing of message failed");

}

static void

{

/* Process size */

arg = args[0];

rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);

session->other_handler = fuzzy_process_handler;

/* Prepare args */

sargs[0] = cmd;

sargs[1] = value;

sargs[2] = flag;

}

static void

{

fuzzy_controller_handler (args, session, FUZZY_WRITE);

}

static void

{

fuzzy_controller_handler (args, session, FUZZY_DEL);

}

fuzzy_mime_filter (struct worker_task *task)

{

/* XXX: remove this */

#define DEFAULT_STATFILE_PREFIX "./"

struct regexp_module_item {

gpointer lua_function;

};

struct autolearn_data {

float weight;

};

struct regexp_ctx {

GHashTable *autolearn_symbols;

memory_pool_t *regexp_pool;

memory_pool_t *dynamic_pool;

};

struct regexp_json_buf {

size_t buflen;

struct config_file *cfg;

};

static struct regexp_ctx *regexp_module_ctx = NULL;

static gboolean rspamd_regexp_match_number (struct worker_task *task, GList * args, void *unused);

static gboolean rspamd_raw_header_exists (struct worker_task *task, GList * args, void *unused);

static gboolean rspamd_check_smtp_data (struct worker_task *task, GList * args, void *unused);

static void

regexp_dynamic_insert_result (struct worker_task *task, void *user_data)

{

insert_result (task, symbol, 1, NULL);

}

static gboolean

{

bzero (ip_buf, sizeof (ip_buf));

bzero (mask_buf, sizeof (mask_buf));

/* Process regexp expression */

static gboolean

{

struct expression *e, *cur;

/* Callbacks for reading json dynamic rules */

{

struct regexp_json_buf *jb;

size_t free, off;

json_regexp_fin_cb (memory_pool_t * pool, struct map_cb_data *data)

{

struct regexp_json_buf *jb;

json_t *js, *cur_elt, *cur_nm, *it_val;

json_error_t je;

double score;

gboolean enabled;

struct regexp_module_item *cur_item;

}

/* Init function */

regexp_module_init (struct config_file *cfg, struct module_ctx **ctx)

{

regexp_module_ctx = g_malloc (sizeof (struct regexp_ctx));

* SYMBOL:statfile:weight

*/

void

{

struct autolearn_data *d;

p = memory_pool_strdup (regexp_module_ctx->regexp_pool, value);

d = memory_pool_alloc (regexp_module_ctx->regexp_pool, sizeof (struct autolearn_data));

}

}

regexp_module_config (struct config_file *cfg)

{

GList *cur_opt = NULL;

struct module_opt *cur;

struct regexp_module_item *cur_item;

struct regexp_json_buf *jb, **pjb;

if ((value = get_module_opt (cfg, "regexp", "statfile_prefix")) != NULL) {

return res;

}

regexp_module_reconfig (struct config_file *cfg)

{

memory_pool_delete (regexp_module_ctx->regexp_pool);

return regexp_module_config (cfg);

}

{

gsize headerlen = strlen (headerv);

if (headers == NULL) {

}

static gsize

{

struct mime_text_part *part;

GList *cur, *headerlist;

GRegex *regexp;

.re = re,

.found = FALSE

};

if (re == NULL) {

}

cur = headerlist;

while (cur) {

if (cur->data && g_regex_match_full (re->regexp, cur->data, -1, 0, 0, NULL, &err) == TRUE) {

if (G_UNLIKELY (re->is_test)) {

}

task_cache_add (task, re, 1);

return 1;

}

else if (G_UNLIKELY (re->is_test)) {

}

if (err != NULL) {

msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);

return 1;

}

else if (G_UNLIKELY (re->is_test)) {

}

if (err != NULL) {

msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);

if (g_regex_match_full (re->raw_regexp, task->msg->begin, task->msg->len, 0, 0, NULL, &err) == TRUE) {

if (G_UNLIKELY (re->is_test)) {

}

task_cache_add (task, re, 1);

return 1;

}

else if (G_UNLIKELY (re->is_test)) {

}

if (err != NULL) {

msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);

task_cache_add (task, re, 0);

return 0;

}

/* No header was found */

task_cache_add (task, re, 0);

return 0;

{

struct expression *it = (*e)->next;

gboolean ret = FALSE, is_nearest = TRUE;

/* Skip nearest logical operators from optimization */

if (!it || (it->type == EXPR_OPERATION && it->content.operation != '!')) {

}

static gboolean

{

GQueue *stack;

gsize cur, op1, op2;

}

}

regexp_common_filter (struct worker_task *task)

{

/* XXX: remove this shit too */

static gboolean

rspamd_regexp_match_number (struct worker_task *task, GList * args, void *unused)

{

struct expression_argument *arg;

GList *cur;

msg_warn ("invalid argument to function is passed");

return FALSE;

}

return FALSE;

}

}

static gboolean

{

struct rspamd_regexp *re;

if (*re_text == '/') {

/* This is a regexp */

if ((re = re_cache_check (re_text, task->cfg->cfg_pool)) == NULL) {

if (re == NULL) {

msg_warn ("cannot compile regexp for function");

return FALSE;

}

}

if ((r = task_cache_check (task, re)) == -1) {

if (g_regex_match (re->regexp, what, 0, NULL) == TRUE) {

{

struct expression_argument *arg;

GList *cur, *rcpt_list = NULL;

if (args == NULL) {

msg_warn ("no parameters to function");

#define DEFAULT_SYMBOL_ALLOW "R_SPF_ALLOW"

struct spf_ctx {

memory_pool_t *spf_pool;

radix_tree_t *whitelist_ip;

static void spf_symbol_callback (struct worker_task *task, void *unused);

spf_module_init (struct config_file *cfg, struct module_ctx **ctx)

{

spf_module_ctx = g_malloc (sizeof (struct spf_ctx));

}

spf_module_config (struct config_file *cfg)

{

spf_module_ctx->whitelist_ip = radix_tree_create ();

return res;

}

spf_module_reconfig (struct config_file *cfg)

{

memory_pool_delete (spf_module_ctx->spf_pool);

{

GList *cur;

struct spf_addr *addr;

if (record) {

cur = g_list_first (record->addrs);

static struct surbl_ctx *surbl_module_ctx = NULL;

static void surbl_test_url (struct worker_task *task, void *user_data);

static void dns_callback (struct rspamd_dns_reply *reply, gpointer arg);

#define NO_REGEXP (gpointer)-1

exception_insert (gpointer st, gconstpointer key, gpointer value)

{

GHashTable **t = st;

f_str_t *val;

p ++;

}

if (level >= MAX_LEVELS) {

return;

}

val = g_malloc (sizeof (f_str_t));

val->len = strlen (key);

if (t[level] == NULL) {

t[level] = g_hash_table_new_full (fstr_strcase_hash, fstr_strcase_equal, g_free, NULL);

fin_exceptions_list (memory_pool_t * pool, struct map_cb_data *data)

{

GHashTable **t;

if (data->prev_data) {

t = data->prev_data;

redirector_insert (gpointer st, gconstpointer key, gpointer value)

{

GHashTable *t = st;

gchar *new;

gsize len;

GRegex *re = NO_REGEXP;

}

}

surbl_module_init (struct config_file *cfg, struct module_ctx **ctx)

{

surbl_module_ctx = g_malloc (sizeof (struct surbl_ctx));

return 0;

}

surbl_module_config (struct config_file *cfg)

{

GList *cur_opt;

struct suffix_item *new_suffix;

struct surbl_bit_item *new_bit;

guint32 bit;

gint i, idx;

new_bit = memory_pool_alloc (surbl_module_ctx->surbl_pool, sizeof (struct surbl_bit_item));

new_bit->bit = bit;

new_bit->symbol = memory_pool_strdup (surbl_module_ctx->surbl_pool, cur->value);

surbl_module_ctx->bits = g_list_prepend (surbl_module_ctx->bits, new_bit);

}

}

return TRUE;

}

surbl_module_reconfig (struct config_file *cfg)

{

/* Delete pool and objects */

format_surbl_request (memory_pool_t * pool, f_str_t * hostname, struct suffix_item *suffix,

gboolean append_suffix, GError ** err, gboolean forced)

{

GHashTable *t;

gboolean is_numeric = TRUE;

guint64 ip_num;

f_str_t f;

/* This is ip address */

result = memory_pool_alloc (pool, len);

r = rspamd_snprintf (result, len, "%*s.%*s.%*s.%*s",

dots[2] + 1,

dots[1] + 1,

dots[0] + 1,

hostname->begin);

}

else if (is_numeric && dots_num == 0) {

ip_num &= 0xFFFFFFFF;

/* Get octets */

r = rspamd_snprintf (result, len, "%ud.%ud.%ud.%ud",

}

else {

/* Not a numeric url */

}

if (level != MAX_LEVELS) {

if (level == 0) {

}

else {

r = rspamd_snprintf (result, len, "%*s",

dots[level - 1] + 1);

}

}

else if (dots_num >= 2) {

r = rspamd_snprintf (result, len, "%*s",

dots[dots_num - 2] + 1);

}

else {

}

}

r += rspamd_snprintf (result + r, len - r, ".%s", suffix->suffix);

}

return result;

}

make_surbl_requests (struct uri *url, struct worker_task *task, GTree * tree,

struct suffix_item *suffix, gboolean forced)

{

f_str_t f;

GError *err = NULL;

struct dns_param *param;

}

static void

{

GList *cur;

struct surbl_bit_item *bit;

if ((c = strchr (suffix->symbol, '%')) != NULL && *(c + 1) == 'b') {

cur = g_list_first (surbl_module_ctx->bits);

while (cur) {

bit = (struct surbl_bit_item *)cur->data;

len = strlen (suffix->symbol) - 2 + strlen (bit->symbol) + 1;

*c = '\0';

symbol = memory_pool_alloc (task->task_pool, len);

if (reply->code == DNS_RC_NOERROR && reply->elements) {

msg_info ("<%s> domain [%s] is in surbl %s", param->task->message_id, param->host_resolve, param->suffix->suffix);

elt = reply->elements->data;

}

else {

debug_task ("<%s> domain [%s] is not in surbl %s", param->task->message_id, param->host_resolve, param->suffix->suffix);

memcached_callback (memcached_ctx_t * ctx, memc_error_t error, void *data)

{

struct memcached_param *param = (struct memcached_param *)data;

switch (ctx->op) {

case CMD_CONNECT:

}

}

else {

/* Do not check DNS for urls that have count more than max_urls */

if (*url_count > surbl_module_ctx->max_urls) {

msg_info ("url '%s' has count %d, max: %d", struri (param->url), *url_count, surbl_module_ctx->max_urls);

struct memcached_server *selected;

memcached_param_t *cur_param;

gchar *sum_str;

param = memory_pool_alloc (task->task_pool, sizeof (struct memcached_param));

cur_param = memory_pool_alloc0 (task->task_pool, sizeof (memcached_param_t));

param->url = url;

param->task = task;

param->ctx = memory_pool_alloc0 (task->task_pool, sizeof (memcached_ctx_t));

cur_param->buf = (u_char *) url_count;

sum_str = g_compute_checksum_for_string (G_CHECKSUM_MD5, struri (url), -1);

g_strlcpy (cur_param->key, sum_str, sizeof (cur_param->key));

}

static void

{

struct redirector_param *param = (struct redirector_param *)arg;

struct worker_task *task = param->task;

struct timeval *timeout;

switch (param->state) {

case STATE_CONNECT:

static void

register_redirector_call (struct uri *url, struct worker_task *task, GTree * url_tree, struct suffix_item *suffix)

{

struct redirector_param *param;

struct timeval *timeout;

struct redirector_upstream *selected;

struct worker_task *task = param->task;

struct uri *url = value;

f_str_t f;

GRegex *re;

guint idx;

memory_pool_add_destructor (task->task_pool, (pool_destruct_func) g_tree_destroy, url_tree);

}

surbl_filter (struct worker_task *task)

{

/* XXX: remove this shit */

urls_command_handler (struct worker_task *task)

{

GList *cur;

struct uri *url;

GError *err = NULL;

GTree *url_tree;

buflen += sizeof (RSPAMD_REPLY_BANNER " 0 OK" CRLF CRLF "Urls: ");

r = rspamd_snprintf (outbuf, buflen, "%s 0 %s" CRLF, (task->proto == SPAMC_PROTO) ? SPAMD_REPLY_BANNER : RSPAMD_REPLY_BANNER, "OK");

f.len = url->hostlen;

if ((urlstr = format_surbl_request (task->task_pool, &f, NULL, FALSE, &err, FALSE)) != NULL) {

if (g_list_next (cur) != NULL) {

}

else {

}

}

}

};

struct surbl_ctx {

GList *suffixes;

GList *bits;

GHashTable **exceptions;

GHashTable *whitelist;

GHashTable *redirector_hosts;

rspamd_trie_t *redirector_trie;

GPtrArray *redirector_ptrs;

struct redirector_upstream *redirectors;

guint32 redirectors_number;

memory_pool_t *surbl_pool;

};

struct suffix_item {

};

struct dns_param {

struct uri *url;

struct worker_task *task;

struct suffix_item *suffix;

};

STATE_READ,

} state;

struct event ev;

GTree *tree;

struct suffix_item *suffix;

};

};

struct surbl_bit_item {

};

#endif