/*
* Bayesian classifier
*/
+#include "binlog.h"
+#include "cfg_file.h"
#include "classifiers.h"
-#include "tokenizers/tokenizers.h"
-#include "main.h"
#include "filter.h"
-#include "cfg_file.h"
-#include "binlog.h"
#include "lua/lua_common.h"
+#include "main.h"
+#include "tokenizers/tokenizers.h"
#define LOCAL_PROB_DENOM 16.0
}
struct bayes_statfile_data {
- guint64 hits;
- guint64 total_hits;
- double value;
- struct rspamd_statfile_config *st;
- stat_file_t *file;
+ guint64 hits;
+ guint64 total_hits;
+ double value;
+ struct rspamd_statfile_config *st;
+ stat_file_t *file;
};
struct bayes_callback_data {
- statfile_pool_t *pool;
- struct classifier_ctx *ctx;
- gboolean in_class;
- time_t now;
- stat_file_t *file;
- struct bayes_statfile_data *statfiles;
- guint32 statfiles_num;
- guint64 total_spam;
- guint64 total_ham;
- guint64 processed_tokens;
- gsize max_tokens;
- double spam_probability;
- double ham_probability;
+ statfile_pool_t *pool;
+ struct classifier_ctx *ctx;
+ gboolean in_class;
+ time_t now;
+ stat_file_t *file;
+ struct bayes_statfile_data *statfiles;
+ guint32 statfiles_num;
+ guint64 total_spam;
+ guint64 total_ham;
+ guint64 processed_tokens;
+ gsize max_tokens;
+ double spam_probability;
+ double ham_probability;
};
-static gboolean
+static gboolean
bayes_learn_callback (gpointer key, gpointer value, gpointer data)
{
- token_node_t *node = key;
- struct bayes_callback_data *cd = data;
- gint c;
- guint64 v;
+ token_node_t *node = key;
+ struct bayes_callback_data *cd = data;
+ gint c;
+ guint64 v;
c = (cd->in_class) ? 1 : -1;
/* Consider that not found blocks have value 1 */
- v = statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2, cd->now);
+ v =
+ statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2,
+ cd->now);
if (v == 0 && c > 0) {
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, c);
- cd->processed_tokens ++;
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ c);
+ cd->processed_tokens++;
}
else if (v != 0) {
if (G_LIKELY (c > 0)) {
- v ++;
+ v++;
}
- else if (c < 0){
+ else if (c < 0) {
if (v != 0) {
- v --;
+ v--;
}
}
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, v);
- cd->processed_tokens ++;
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ v);
+ cd->processed_tokens++;
}
if (cd->max_tokens != 0 && cd->processed_tokens > cd->max_tokens) {
return 0;
}
sum = prob;
- for (i = 1; i < freedom_deg / 2; i ++) {
+ for (i = 1; i < freedom_deg / 2; i++) {
prob *= value / (gdouble)i;
sum += prob;
}
bayes_classify_callback (gpointer key, gpointer value, gpointer data)
{
- token_node_t *node = key;
- struct bayes_callback_data *cd = data;
- guint i;
- struct bayes_statfile_data *cur;
- guint64 spam_count = 0, ham_count = 0, total_count = 0;
- double spam_prob, spam_freq, ham_freq, bayes_spam_prob;
+ token_node_t *node = key;
+ struct bayes_callback_data *cd = data;
+ guint i;
+ struct bayes_statfile_data *cur;
+ guint64 spam_count = 0, ham_count = 0, total_count = 0;
+ double spam_prob, spam_freq, ham_freq, bayes_spam_prob;
- for (i = 0; i < cd->statfiles_num; i ++) {
+ for (i = 0; i < cd->statfiles_num; i++) {
cur = &cd->statfiles[i];
- cur->value = statfile_pool_get_block (cd->pool, cur->file, node->h1, node->h2, cd->now);
+ cur->value = statfile_pool_get_block (cd->pool,
+ cur->file,
+ node->h1,
+ node->h2,
+ cd->now);
if (cur->value > 0) {
cur->total_hits += cur->value;
if (cur->st->is_spam) {
bayes_spam_prob = (0.5 + spam_prob * total_count) / (1. + total_count);
cd->spam_probability += log (bayes_spam_prob);
cd->ham_probability += log (1. - bayes_spam_prob);
- cd->processed_tokens ++;
+ cd->processed_tokens++;
}
if (cd->max_tokens != 0 && cd->processed_tokens > cd->max_tokens) {
return FALSE;
}
-struct classifier_ctx*
+struct classifier_ctx *
bayes_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cfg)
{
- struct classifier_ctx *ctx = rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
+ struct classifier_ctx *ctx =
+ rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
ctx->pool = pool;
ctx->cfg = cfg;
}
gboolean
-bayes_classify (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L)
+bayes_classify (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ lua_State *L)
{
- struct bayes_callback_data data;
- gchar *value;
- gint nodes, i = 0, selected_st = -1, cnt;
- gint minnodes;
- guint64 maxhits = 0, rev;
- double final_prob, h, s;
- struct rspamd_statfile_config *st;
- stat_file_t *file;
- GList *cur;
- char *sumbuf;
+ struct bayes_callback_data data;
+ gchar *value;
+ gint nodes, i = 0, selected_st = -1, cnt;
+ gint minnodes;
+ guint64 maxhits = 0, rev;
+ double final_prob, h, s;
+ struct rspamd_statfile_config *st;
+ stat_file_t *file;
+ GList *cur;
+ char *sumbuf;
g_assert (pool != NULL);
g_assert (ctx != NULL);
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
minnodes = strtol (value, NULL, 10);
nodes = g_tree_nnodes (input);
if (nodes > FEATURE_WINDOW_SIZE) {
cur = call_classifier_pre_callbacks (ctx->cfg, task, FALSE, FALSE, L);
if (cur) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, cur);
}
else {
cur = ctx->cfg->statfiles;
data.ham_probability = 0;
data.total_ham = 0;
data.total_spam = 0;
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
minnodes = rspamd_config_parse_limit (value, -1);
data.max_tokens = minnodes;
}
/* Select statfile to classify */
st = cur->data;
if ((file = statfile_pool_is_open (pool, st->path)) == NULL) {
- if ((file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+ if ((file =
+ statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
msg_warn ("cannot open %s", st->path);
cur = g_list_next (cur);
- data.statfiles_num --;
+ data.statfiles_num--;
continue;
}
}
}
cur = g_list_next (cur);
- i ++;
+ i++;
}
cnt = i;
final_prob = 0;
}
else {
- h = 1 - inv_chi_square (-2. * data.spam_probability, 2 * data.processed_tokens);
- s = 1 - inv_chi_square (-2. * data.ham_probability, 2 * data.processed_tokens);
+ h = 1 - inv_chi_square (-2. * data.spam_probability,
+ 2 * data.processed_tokens);
+ s = 1 - inv_chi_square (-2. * data.ham_probability,
+ 2 * data.processed_tokens);
final_prob = (s + 1 - h) / 2.;
}
if (data.processed_tokens > 0 && fabs (final_prob - 0.5) > 0.05) {
sumbuf = rspamd_mempool_alloc (task->task_pool, 32);
- for (i = 0; i < cnt; i ++) {
+ for (i = 0; i < cnt; i++) {
if ((final_prob > 0.5 && !data.statfiles[i].st->is_spam) ||
- (final_prob < 0.5 && data.statfiles[i].st->is_spam)) {
+ (final_prob < 0.5 && data.statfiles[i].st->is_spam)) {
continue;
}
if (data.statfiles[i].total_hits > maxhits) {
}
}
if (selected_st == -1) {
- msg_err ("unexpected classifier error: cannot select desired statfile");
+ msg_err (
+ "unexpected classifier error: cannot select desired statfile");
}
else {
/* Calculate ham probability correctly */
}
rspamd_snprintf (sumbuf, 32, "%.2f%%", final_prob * 100.);
cur = g_list_prepend (NULL, sumbuf);
- insert_result (task, data.statfiles[selected_st].st->symbol, final_prob, cur);
+ insert_result (task,
+ data.statfiles[selected_st].st->symbol,
+ final_prob,
+ cur);
}
}
}
gboolean
-bayes_learn (struct classifier_ctx* ctx, statfile_pool_t *pool, const char *symbol, GTree *input,
- gboolean in_class, double *sum, double multiplier, GError **err)
+bayes_learn (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ const char *symbol,
+ GTree *input,
+ gboolean in_class,
+ double *sum,
+ double multiplier,
+ GError **err)
{
- struct bayes_callback_data data;
- gchar *value;
- gint nodes;
- gint minnodes;
- struct rspamd_statfile_config *st, *sel_st = NULL;
- stat_file_t *to_learn;
- GList *cur;
+ struct bayes_callback_data data;
+ gchar *value;
+ gint nodes;
+ gint minnodes;
+ struct rspamd_statfile_config *st, *sel_st = NULL;
+ stat_file_t *to_learn;
+ GList *cur;
g_assert (pool != NULL);
g_assert (ctx != NULL);
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
minnodes = strtol (value, NULL, 10);
nodes = g_tree_nnodes (input);
if (nodes > FEATURE_WINDOW_SIZE) {
nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
}
if (nodes < minnodes) {
- msg_info ("do not learn message as it has too few tokens: %d, while %d min", nodes, minnodes);
+ msg_info (
+ "do not learn message as it has too few tokens: %d, while %d min",
+ nodes,
+ minnodes);
*sum = 0;
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "message contains too few tokens: %d, while min is %d",
- nodes, (int)minnodes);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "message contains too few tokens: %d, while min is %d",
+ nodes, (int)minnodes);
return FALSE;
}
}
data.ctx = ctx;
data.processed_tokens = 0;
data.processed_tokens = 0;
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
minnodes = rspamd_config_parse_limit (value, -1);
data.max_tokens = minnodes;
}
}
if (sel_st == NULL) {
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "cannot find statfile for symbol: %s",
- symbol);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot find statfile for symbol: %s",
+ symbol);
return FALSE;
}
if ((to_learn = statfile_pool_is_open (pool, sel_st->path)) == NULL) {
- if ((to_learn = statfile_pool_open (pool, sel_st->path, sel_st->size, FALSE)) == NULL) {
+ if ((to_learn =
+ statfile_pool_open (pool, sel_st->path, sel_st->size,
+ FALSE)) == NULL) {
msg_warn ("cannot open %s", sel_st->path);
if (statfile_pool_create (pool, sel_st->path, sel_st->size) == -1) {
msg_err ("cannot create statfile %s", sel_st->path);
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "cannot create statfile: %s",
- sel_st->path);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot create statfile: %s",
+ sel_st->path);
return FALSE;
}
- if ((to_learn = statfile_pool_open (pool, sel_st->path, sel_st->size, FALSE)) == NULL) {
+ if ((to_learn =
+ statfile_pool_open (pool, sel_st->path, sel_st->size,
+ FALSE)) == NULL) {
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "cannot open statfile %s after creation",
- sel_st->path);
- msg_err ("cannot open statfile %s after creation", sel_st->path);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot open statfile %s after creation",
+ sel_st->path);
+ msg_err ("cannot open statfile %s after creation",
+ sel_st->path);
return FALSE;
}
}
}
gboolean
-bayes_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
- GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err)
+bayes_learn_spam (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ gboolean is_spam,
+ lua_State *L,
+ GError **err)
{
- struct bayes_callback_data data;
- gchar *value;
- gint nodes;
- gint minnodes;
- struct rspamd_statfile_config *st;
- stat_file_t *file;
- GList *cur;
- gboolean skip_labels;
+ struct bayes_callback_data data;
+ gchar *value;
+ gint nodes;
+ gint minnodes;
+ struct rspamd_statfile_config *st;
+ stat_file_t *file;
+ GList *cur;
+ gboolean skip_labels;
g_assert (pool != NULL);
g_assert (ctx != NULL);
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
minnodes = strtol (value, NULL, 10);
nodes = g_tree_nnodes (input);
if (nodes > FEATURE_WINDOW_SIZE) {
}
if (nodes < minnodes) {
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "message contains too few tokens: %d, while min is %d",
- nodes, (int)minnodes);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "message contains too few tokens: %d, while min is %d",
+ nodes, (int)minnodes);
return FALSE;
}
}
cur = call_classifier_pre_callbacks (ctx->cfg, task, TRUE, is_spam, L);
if (cur) {
skip_labels = FALSE;
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, cur);
}
else {
/* Do not try to learn specific statfiles if pre callback returned nil */
data.in_class = TRUE;
data.processed_tokens = 0;
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
minnodes = rspamd_config_parse_limit (value, -1);
data.max_tokens = minnodes;
}
continue;
}
if ((file = statfile_pool_is_open (pool, st->path)) == NULL) {
- if ((file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+ if ((file =
+ statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
msg_warn ("cannot open %s", st->path);
if (statfile_pool_create (pool, st->path, st->size) == -1) {
msg_err ("cannot create statfile %s", st->path);
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "cannot create statfile: %s",
- st->path);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot create statfile: %s",
+ st->path);
return FALSE;
}
- if ((file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+ if ((file =
+ statfile_pool_open (pool, st->path, st->size,
+ FALSE)) == NULL) {
g_set_error (err,
- bayes_error_quark(), /* error domain */
- 1, /* error code */
- "cannot open statfile %s after creation",
- st->path);
- msg_err ("cannot open statfile %s after creation", st->path);
+ bayes_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot open statfile %s after creation",
+ st->path);
+ msg_err ("cannot open statfile %s after creation",
+ st->path);
return FALSE;
}
}
}
GList *
-bayes_weights (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task)
+bayes_weights (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task)
{
/* This function is unimplemented with new normalizer */
return NULL;
#include "classifiers.h"
-struct classifier classifiers[] = {
- {
- .name = "winnow",
- .init_func = winnow_init,
- .classify_func = winnow_classify,
- .learn_func = winnow_learn,
- .learn_spam_func = winnow_learn_spam,
- .weights_func = winnow_weights
- },
- {
- .name = "bayes",
- .init_func = bayes_init,
- .classify_func = bayes_classify,
- .learn_func = bayes_learn,
- .learn_spam_func = bayes_learn_spam,
- .weights_func = bayes_weights
- }
+struct classifier classifiers[] = {
+ {
+ .name = "winnow",
+ .init_func = winnow_init,
+ .classify_func = winnow_classify,
+ .learn_func = winnow_learn,
+ .learn_spam_func = winnow_learn_spam,
+ .weights_func = winnow_weights
+ },
+ {
+ .name = "bayes",
+ .init_func = bayes_init,
+ .classify_func = bayes_classify,
+ .learn_func = bayes_learn,
+ .learn_spam_func = bayes_learn_spam,
+ .weights_func = bayes_weights
+ }
};
-struct classifier *
+struct classifier *
get_classifier (const char *name)
{
- guint i;
+ guint i;
for (i = 0; i < sizeof (classifiers) / sizeof (classifiers[0]); i++) {
if (strcmp (classifiers[i].name, name) == 0) {
/* Common classifier structure */
struct classifier {
char *name;
- struct classifier_ctx* (*init_func)(rspamd_mempool_t *pool, struct rspamd_classifier_config *cf);
- gboolean (*classify_func)(struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L);
- gboolean (*learn_func)(struct classifier_ctx* ctx, statfile_pool_t *pool,
- const char *symbol, GTree *input, gboolean in_class,
- double *sum, double multiplier, GError **err);
- gboolean (*learn_spam_func)(struct classifier_ctx* ctx, statfile_pool_t *pool,
- GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err);
- GList* (*weights_func)(struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task);
+ struct classifier_ctx * (*init_func)(rspamd_mempool_t *pool,
+ struct rspamd_classifier_config *cf);
+ gboolean (*classify_func)(struct classifier_ctx * ctx,
+ statfile_pool_t *pool, GTree *input, struct rspamd_task *task,
+ lua_State *L);
+ gboolean (*learn_func)(struct classifier_ctx * ctx, statfile_pool_t *pool,
+ const char *symbol, GTree *input, gboolean in_class,
+ double *sum, double multiplier, GError **err);
+ gboolean (*learn_spam_func)(struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L,
+ GError **err);
+ GList * (*weights_func)(struct classifier_ctx * ctx, statfile_pool_t *pool,
+ GTree *input, struct rspamd_task *task);
};
/* Get classifier structure by name or return NULL if this name is not found */
-struct classifier* get_classifier (const char *name);
+struct classifier * get_classifier (const char *name);
/* Winnow algorithm */
-struct classifier_ctx* winnow_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cf);
-gboolean winnow_classify (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L);
-gboolean winnow_learn (struct classifier_ctx* ctx, statfile_pool_t *pool, const char *symbol, GTree *input,
- gboolean in_class, double *sum, double multiplier, GError **err);
-gboolean winnow_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
- GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err);
-GList *winnow_weights (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task);
+struct classifier_ctx * winnow_init (rspamd_mempool_t *pool,
+ struct rspamd_classifier_config *cf);
+gboolean winnow_classify (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ lua_State *L);
+gboolean winnow_learn (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ const char *symbol,
+ GTree *input,
+ gboolean in_class,
+ double *sum,
+ double multiplier,
+ GError **err);
+gboolean winnow_learn_spam (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ gboolean is_spam,
+ lua_State *L,
+ GError **err);
+GList * winnow_weights (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task);
/* Bayes algorithm */
-struct classifier_ctx* bayes_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cf);
-gboolean bayes_classify (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L);
-gboolean bayes_learn (struct classifier_ctx* ctx, statfile_pool_t *pool, const char *symbol, GTree *input,
- gboolean in_class, double *sum, double multiplier, GError **err);
-gboolean bayes_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
- GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err);
-GList *bayes_weights (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task);
+struct classifier_ctx * bayes_init (rspamd_mempool_t *pool,
+ struct rspamd_classifier_config *cf);
+gboolean bayes_classify (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ lua_State *L);
+gboolean bayes_learn (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ const char *symbol,
+ GTree *input,
+ gboolean in_class,
+ double *sum,
+ double multiplier,
+ GError **err);
+gboolean bayes_learn_spam (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ gboolean is_spam,
+ lua_State *L,
+ GError **err);
+GList * bayes_weights (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task);
/* Array of all defined classifiers */
extern struct classifier classifiers[];
* Winnow classifier
*/
+#include "cfg_file.h"
#include "classifiers.h"
-#include "tokenizers/tokenizers.h"
-#include "main.h"
#include "filter.h"
-#include "cfg_file.h"
#include "lua/lua_common.h"
+#include "main.h"
+#include "tokenizers/tokenizers.h"
#define WINNOW_PROMOTION 1.23
#define WINNOW_DEMOTION 0.83
}
struct winnow_callback_data {
- statfile_pool_t *pool;
- struct classifier_ctx *ctx;
- stat_file_t *file;
- stat_file_t *learn_file;
- long double sum;
- long double start;
- double multiplier;
- guint32 count;
- guint32 new_blocks;
- gboolean in_class;
- gboolean do_demote;
- gboolean fresh_run;
- time_t now;
+ statfile_pool_t *pool;
+ struct classifier_ctx *ctx;
+ stat_file_t *file;
+ stat_file_t *learn_file;
+ long double sum;
+ long double start;
+ double multiplier;
+ guint32 count;
+ guint32 new_blocks;
+ gboolean in_class;
+ gboolean do_demote;
+ gboolean fresh_run;
+ time_t now;
};
static const double max_common_weight = MAX_WEIGHT * WINNOW_DEMOTION;
-static gboolean
+static gboolean
winnow_classify_callback (gpointer key, gpointer value, gpointer data)
{
- token_node_t *node = key;
- struct winnow_callback_data *cd = data;
- double v;
+ token_node_t *node = key;
+ struct winnow_callback_data *cd = data;
+ double v;
/* Consider that not found blocks have value 1 */
- v = statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2, cd->now);
+ v =
+ statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2,
+ cd->now);
if (fabs (v) > ALPHA) {
cd->sum += v;
}
else {
cd->sum += 1.0;
- cd->new_blocks ++;
+ cd->new_blocks++;
}
cd->count++;
return FALSE;
}
-static gboolean
+static gboolean
winnow_learn_callback (gpointer key, gpointer value, gpointer data)
{
- token_node_t *node = key;
- struct winnow_callback_data *cd = data;
- double v, c;
-
- c = (cd->in_class) ? WINNOW_PROMOTION * cd->multiplier : WINNOW_DEMOTION / cd->multiplier;
+ token_node_t *node = key;
+ struct winnow_callback_data *cd = data;
+ double v, c;
+
+ c = (cd->in_class) ? WINNOW_PROMOTION * cd->multiplier : WINNOW_DEMOTION /
+ cd->multiplier;
/* Consider that not found blocks have value 1 */
- v = statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2, cd->now);
+ v =
+ statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2,
+ cd->now);
if (fabs (v) < ALPHA) {
/* Block not found, insert new */
cd->start += 1;
if (cd->file == cd->learn_file) {
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, c);
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ c);
node->value = c;
- cd->new_blocks ++;
+ cd->new_blocks++;
}
}
else {
node->extra = 0;
}
else {
- node->extra ++;
+ node->extra++;
}
node->value = v;
-
+
if (node->extra > 1) {
- /*
+ /*
* Assume that this node is common for several statfiles, so
* decrease its weight proportianally
*/
if (node->value > max_common_weight) {
/* Static fluctuation */
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, 0.);
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ 0.);
node->value = 0.;
}
else if (node->value > WINNOW_PROMOTION * cd->multiplier) {
node->value *= c;
}
else {
- /*
+ /*
* Too high token value that exists also in other
* statfiles, may be statistic error, so decrease it
* slightly
else {
node->value = WINNOW_DEMOTION / cd->multiplier;
}
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, node->value);
- }
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ node->value);
+ }
}
else if (cd->file == cd->learn_file) {
/* New block or block that is in only one statfile */
else {
node->value *= c;
}
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, node->value);
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ node->value);
}
else if (cd->do_demote) {
/* Demote blocks in file */
node->value *= WINNOW_DEMOTION / cd->multiplier;
- statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, node->value);
+ statfile_pool_set_block (cd->pool,
+ cd->file,
+ node->h1,
+ node->h2,
+ cd->now,
+ node->value);
}
}
return FALSE;
}
-struct classifier_ctx *
+struct classifier_ctx *
winnow_init (rspamd_mempool_t * pool, struct rspamd_classifier_config *cfg)
{
- struct classifier_ctx *ctx = rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
+ struct classifier_ctx *ctx =
+ rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
ctx->pool = pool;
ctx->cfg = cfg;
}
gboolean
-winnow_classify (struct classifier_ctx *ctx, statfile_pool_t * pool, GTree * input, struct rspamd_task *task, lua_State *L)
+winnow_classify (struct classifier_ctx *ctx,
+ statfile_pool_t * pool,
+ GTree * input,
+ struct rspamd_task *task,
+ lua_State *L)
{
- struct winnow_callback_data data;
- char *sumbuf, *value;
- long double res = 0., max = 0.;
- GList *cur;
- struct rspamd_statfile_config *st, *sel = NULL;
- int nodes, minnodes;
+ struct winnow_callback_data data;
+ char *sumbuf, *value;
+ long double res = 0., max = 0.;
+ GList *cur;
+ struct rspamd_statfile_config *st, *sel = NULL;
+ int nodes, minnodes;
g_assert (pool != NULL);
g_assert (ctx != NULL);
data.pool = pool;
data.now = time (NULL);
data.ctx = ctx;
-
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
minnodes = strtol (value, NULL, 10);
nodes = g_tree_nnodes (input);
if (nodes > FEATURE_WINDOW_SIZE) {
nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
}
if (nodes < minnodes) {
- msg_info ("do not classify message as it has too few tokens: %d, while %d min", nodes, minnodes);
+ msg_info (
+ "do not classify message as it has too few tokens: %d, while %d min",
+ nodes,
+ minnodes);
return FALSE;
}
}
cur = call_classifier_pre_callbacks (ctx->cfg, task, FALSE, FALSE, L);
if (cur) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, cur);
}
else {
cur = ctx->cfg->statfiles;
data.count = 0;
data.new_blocks = 0;
if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
- if ((data.file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+ if ((data.file =
+ statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
msg_warn ("cannot open %s, skip it", st->path);
cur = g_list_next (cur);
continue;
if (sel != NULL) {
#ifdef WITH_LUA
- max = call_classifier_post_callbacks (ctx->cfg, task, max, L);
+ max = call_classifier_post_callbacks (ctx->cfg, task, max, L);
#endif
#ifdef HAVE_TANHL
- max = tanhl (max);
+ max = tanhl (max);
#else
- /*
- * As some implementations of libm does not support tanhl, try to use
- * tanh
- */
- max = tanh ((double) max);
+ /*
+ * As some implementations of libm does not support tanhl, try to use
+ * tanh
+ */
+ max = tanh ((double) max);
#endif
sumbuf = rspamd_mempool_alloc (task->task_pool, 32);
rspamd_snprintf (sumbuf, 32, "%.2F", max);
}
GList *
-winnow_weights (struct classifier_ctx *ctx, statfile_pool_t * pool, GTree * input, struct rspamd_task *task)
+winnow_weights (struct classifier_ctx *ctx,
+ statfile_pool_t * pool,
+ GTree * input,
+ struct rspamd_task *task)
{
- struct winnow_callback_data data;
- long double res = 0.;
- GList *cur, *resl = NULL;
- struct rspamd_statfile_config *st;
- struct classify_weight *w;
- char *value;
- int nodes, minnodes;
+ struct winnow_callback_data data;
+ long double res = 0.;
+ GList *cur, *resl = NULL;
+ struct rspamd_statfile_config *st;
+ struct classify_weight *w;
+ char *value;
+ int nodes, minnodes;
g_assert (pool != NULL);
g_assert (ctx != NULL);
data.now = time (NULL);
data.ctx = ctx;
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
minnodes = strtol (value, NULL, 10);
nodes = g_tree_nnodes (input);
if (nodes > FEATURE_WINDOW_SIZE) {
nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
}
if (nodes < minnodes) {
- msg_info ("do not classify message as it has too few tokens: %d, while %d min", nodes, minnodes);
+ msg_info (
+ "do not classify message as it has too few tokens: %d, while %d min",
+ nodes,
+ minnodes);
return NULL;
}
}
-
+
cur = ctx->cfg->statfiles;
while (cur) {
st = cur->data;
data.sum = 0;
data.count = 0;
if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
- if ((data.file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+ if ((data.file =
+ statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
msg_warn ("cannot open %s, skip it", st->path);
cur = g_list_next (cur);
continue;
g_tree_foreach (input, winnow_classify_callback, &data);
}
- w = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct classify_weight));
+ w =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct classify_weight));
if (data.count != 0) {
res = data.sum / (double)data.count;
}
resl = g_list_prepend (resl, w);
cur = g_list_next (cur);
}
-
+
if (resl != NULL) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, resl);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, resl);
}
return resl;
gboolean
-winnow_learn (struct classifier_ctx *ctx, statfile_pool_t *pool, const char *symbol,
- GTree * input, int in_class, double *sum, double multiplier, GError **err)
+winnow_learn (struct classifier_ctx *ctx,
+ statfile_pool_t *pool,
+ const char *symbol,
+ GTree * input,
+ int in_class,
+ double *sum,
+ double multiplier,
+ GError **err)
{
- struct winnow_callback_data data = {
+ struct winnow_callback_data data = {
.file = NULL,
.multiplier = multiplier
};
- char *value;
- int nodes, minnodes, iterations = 0;
- struct rspamd_statfile_config *st, *sel_st = NULL;
- stat_file_t *sel = NULL, *to_learn;
- long double res = 0., max = 0., start_value = 0., end_value = 0.;
- double learn_threshold = 0.0;
- GList *cur, *to_demote = NULL;
- gboolean force_learn = FALSE;
+ char *value;
+ int nodes, minnodes, iterations = 0;
+ struct rspamd_statfile_config *st, *sel_st = NULL;
+ stat_file_t *sel = NULL, *to_learn;
+ long double res = 0., max = 0., start_value = 0., end_value = 0.;
+ double learn_threshold = 0.0;
+ GList *cur, *to_demote = NULL;
+ gboolean force_learn = FALSE;
g_assert (pool != NULL);
g_assert (ctx != NULL);
data.ctx = ctx;
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
minnodes = strtol (value, NULL, 10);
nodes = g_tree_nnodes (input);
if (nodes > FEATURE_WINDOW_SIZE) {
nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
}
if (nodes < minnodes) {
- msg_info ("do not learn message as it has too few tokens: %d, while %d min", nodes, minnodes);
+ msg_info (
+ "do not learn message as it has too few tokens: %d, while %d min",
+ nodes,
+ minnodes);
if (sum != NULL) {
*sum = 0;
}
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "message contains too few tokens: %d, while min is %d",
- nodes, minnodes);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "message contains too few tokens: %d, while min is %d",
+ nodes, minnodes);
return FALSE;
}
}
- if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "learn_threshold")) != NULL) {
+ if (ctx->cfg->opts &&
+ (value =
+ g_hash_table_lookup (ctx->cfg->opts, "learn_threshold")) != NULL) {
learn_threshold = strtod (value, NULL);
}
-
+
if (learn_threshold <= 1.0 && learn_threshold >= 0) {
/* Classify message and check target statfile score */
cur = ctx->cfg->statfiles;
/* Open or create all statfiles inside classifier */
st = cur->data;
if (statfile_pool_is_open (pool, st->path) == NULL) {
- if (statfile_pool_open (pool, st->path, st->size, FALSE) == NULL) {
+ if (statfile_pool_open (pool, st->path, st->size,
+ FALSE) == NULL) {
msg_warn ("cannot open %s", st->path);
if (statfile_pool_create (pool, st->path, st->size) == -1) {
msg_err ("cannot create statfile %s", st->path);
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "cannot create statfile: %s",
- st->path);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot create statfile: %s",
+ st->path);
return FALSE;
}
- if (statfile_pool_open (pool, st->path, st->size, FALSE) == NULL) {
+ if (statfile_pool_open (pool, st->path, st->size,
+ FALSE) == NULL) {
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "open statfile %s after creation",
- st->path);
- msg_err ("cannot open statfile %s after creation", st->path);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "open statfile %s after creation",
+ st->path);
+ msg_err ("cannot open statfile %s after creation",
+ st->path);
return FALSE;
}
}
if (sel_st == NULL) {
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "cannot find statfile for symbol %s",
- symbol);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "cannot find statfile for symbol %s",
+ symbol);
msg_err ("cannot find statfile for symbol %s", symbol);
return FALSE;
}
to_learn = statfile_pool_is_open (pool, sel_st->path);
if (to_learn == NULL) {
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
- sel_st->path);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
+ sel_st->path);
return FALSE;
}
/* Check target statfile */
data.count = 0;
if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
- st->path);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
+ st->path);
return FALSE;
}
g_tree_foreach (input, winnow_classify_callback, &data);
}
}
else {
- msg_err ("learn threshold is more than 1 or less than 0, so cannot do learn, please check your configuration");
+ msg_err (
+ "learn threshold is more than 1 or less than 0, so cannot do learn, please check your configuration");
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "bad learn_threshold setting: %.2f",
- learn_threshold);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "bad learn_threshold setting: %.2f",
+ learn_threshold);
return FALSE;
}
/* If to_demote list is empty this message is already classified correctly */
if (max > WINNOW_PROMOTION && to_demote == NULL && !force_learn) {
- msg_info ("this message is already of class %s with threshold %.2f and weight %.2F",
- sel_st->symbol, learn_threshold, max);
+ msg_info (
+ "this message is already of class %s with threshold %.2f and weight %.2F",
+ sel_st->symbol,
+ learn_threshold,
+ max);
goto end;
}
data.learn_file = to_learn;
if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
return FALSE;
}
- if (to_demote != NULL && g_list_find (to_demote, data.file) != NULL) {
+ if (to_demote != NULL &&
+ g_list_find (to_demote, data.file) != NULL) {
data.do_demote = TRUE;
}
else {
}
data.multiplier *= WINNOW_PROMOTION;
- msg_info ("learn iteration %d for statfile %s: %G -> %G, multiplier: %.2f", iterations + 1, symbol,
- start_value, end_value, data.multiplier);
- } while ((in_class ? sel != to_learn : sel == to_learn) && iterations ++ < MAX_LEARN_ITERATIONS);
-
+ msg_info (
+ "learn iteration %d for statfile %s: %G -> %G, multiplier: %.2f",
+ iterations + 1,
+ symbol,
+ start_value,
+ end_value,
+ data.multiplier);
+ } while ((in_class ? sel != to_learn : sel ==
+ to_learn) && iterations++ < MAX_LEARN_ITERATIONS);
+
if (iterations >= MAX_LEARN_ITERATIONS) {
- msg_warn ("learning statfile %s was not fully successfull: iterations count is limited to %d, final sum is %G",
- sel_st->symbol, MAX_LEARN_ITERATIONS, max);
+ msg_warn (
+ "learning statfile %s was not fully successfull: iterations count is limited to %d, final sum is %G",
+ sel_st->symbol,
+ MAX_LEARN_ITERATIONS,
+ max);
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "learning statfile %s was not fully successfull: iterations count is limited to %d",
- sel_st->symbol, MAX_LEARN_ITERATIONS);
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "learning statfile %s was not fully successfull: iterations count is limited to %d",
+ sel_st->symbol, MAX_LEARN_ITERATIONS);
return FALSE;
}
else {
- msg_info ("learned statfile %s successfully with %d iterations and sum %G", sel_st->symbol, iterations + 1, max);
+ msg_info (
+ "learned statfile %s successfully with %d iterations and sum %G",
+ sel_st->symbol,
+ iterations + 1,
+ max);
}
end:
if (sum) {
#ifdef HAVE_TANHL
- *sum = (double)tanhl (max);
+ *sum = (double)tanhl (max);
#else
- /*
- * As some implementations of libm does not support tanhl, try to use
- * tanh
- */
- *sum = tanh ((double) max);
+ /*
+ * As some implementations of libm does not support tanhl, try to use
+ * tanh
+ */
+ *sum = tanh ((double) max);
#endif
}
return TRUE;
}
gboolean
-winnow_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
- GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err)
+winnow_learn_spam (struct classifier_ctx * ctx,
+ statfile_pool_t *pool,
+ GTree *input,
+ struct rspamd_task *task,
+ gboolean is_spam,
+ lua_State *L,
+ GError **err)
{
g_set_error (err,
- winnow_error_quark(), /* error domain */
- 1, /* error code */
- "learn spam is not supported for winnow"
- );
+ winnow_error_quark (), /* error domain */
+ 1, /* error code */
+ "learn spam is not supported for winnow"
+ );
return FALSE;
}
*/
#include "config.h"
-#include "util.h"
#include "http.h"
#include "rspamdclient.h"
+#include "util.h"
#include "utlist.h"
#define DEFAULT_PORT 11333
#define DEFAULT_CONTROL_PORT 11334
-static gchar *connect_str = "localhost";
-static gchar *password = NULL;
-static gchar *ip = NULL;
-static gchar *from = NULL;
-static gchar *deliver_to = NULL;
-static gchar *rcpt = NULL;
-static gchar *user = NULL;
-static gchar *helo = NULL;
-static gchar *hostname = NULL;
-static gchar *classifier = "bayes";
-static gchar *local_addr = NULL;
-static gint weight = 0;
-static gint flag = 0;
-static gint max_requests = 1024;
-static gdouble timeout = 5.0;
-static gboolean pass_all;
-static gboolean tty = FALSE;
-static gboolean verbose = FALSE;
-static gboolean print_commands = FALSE;
-static gboolean json = FALSE;
-static gboolean headers = FALSE;
-static gboolean raw = FALSE;
+static gchar *connect_str = "localhost";
+static gchar *password = NULL;
+static gchar *ip = NULL;
+static gchar *from = NULL;
+static gchar *deliver_to = NULL;
+static gchar *rcpt = NULL;
+static gchar *user = NULL;
+static gchar *helo = NULL;
+static gchar *hostname = NULL;
+static gchar *classifier = "bayes";
+static gchar *local_addr = NULL;
+static gint weight = 0;
+static gint flag = 0;
+static gint max_requests = 1024;
+static gdouble timeout = 5.0;
+static gboolean pass_all;
+static gboolean tty = FALSE;
+static gboolean verbose = FALSE;
+static gboolean print_commands = FALSE;
+static gboolean json = FALSE;
+static gboolean headers = FALSE;
+static gboolean raw = FALSE;
static GOptionEntry entries[] =
{
- { "connect", 'h', 0, G_OPTION_ARG_STRING, &connect_str, "Specify host and port", NULL },
- { "password", 'P', 0, G_OPTION_ARG_STRING, &password, "Specify control password", NULL },
- { "classifier", 'c', 0, G_OPTION_ARG_STRING, &classifier, "Classifier to learn spam or ham", NULL },
- { "weight", 'w', 0, G_OPTION_ARG_INT, &weight, "Weight for fuzzy operations", NULL },
- { "flag", 'f', 0, G_OPTION_ARG_INT, &flag, "Flag for fuzzy operations", NULL },
- { "pass-all", 'p', 0, G_OPTION_ARG_NONE, &pass_all, "Pass all filters", NULL },
- { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "More verbose output", NULL },
- { "ip", 'i', 0, G_OPTION_ARG_STRING, &ip, "Emulate that message was received from specified ip address", NULL },
- { "user", 'u', 0, G_OPTION_ARG_STRING, &user, "Emulate that message was from specified user", NULL },
- { "deliver", 'd', 0, G_OPTION_ARG_STRING, &deliver_to, "Emulate that message is delivered to specified user", NULL },
- { "from", 'F', 0, G_OPTION_ARG_STRING, &from, "Emulate that message is from specified user", NULL },
- { "rcpt", 'r', 0, G_OPTION_ARG_STRING, &rcpt, "Emulate that message is for specified user", NULL },
- { "helo", 0, 0, G_OPTION_ARG_STRING, &helo, "Imitate SMTP HELO passing from MTA", NULL },
- { "hostname", 0, 0, G_OPTION_ARG_STRING, &hostname, "Imitate hostname passing from MTA", NULL },
- { "timeout", 't', 0, G_OPTION_ARG_DOUBLE, &timeout, "Time in seconds to wait for a reply", NULL },
- { "bind", 'b', 0, G_OPTION_ARG_STRING, &local_addr, "Bind to specified ip address", NULL },
- { "commands", 0, 0, G_OPTION_ARG_NONE, &print_commands, "List available commands", NULL },
- { "json", 'j', 0, G_OPTION_ARG_NONE, &json, "Output json reply", NULL },
- { "headers", 0, 0, G_OPTION_ARG_NONE, &headers, "Output HTTP headers", NULL },
- { "raw", 0, 0, G_OPTION_ARG_NONE, &raw, "Output raw reply from rspamd", NULL },
- { "max-requests", 'n', 0, G_OPTION_ARG_INT, &max_requests, "Maximum count of parallel requests to rspamd", NULL },
- { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
+ { "connect", 'h', 0, G_OPTION_ARG_STRING, &connect_str,
+ "Specify host and port", NULL },
+ { "password", 'P', 0, G_OPTION_ARG_STRING, &password,
+ "Specify control password", NULL },
+ { "classifier", 'c', 0, G_OPTION_ARG_STRING, &classifier,
+ "Classifier to learn spam or ham", NULL },
+ { "weight", 'w', 0, G_OPTION_ARG_INT, &weight,
+ "Weight for fuzzy operations", NULL },
+ { "flag", 'f', 0, G_OPTION_ARG_INT, &flag, "Flag for fuzzy operations",
+ NULL },
+ { "pass-all", 'p', 0, G_OPTION_ARG_NONE, &pass_all, "Pass all filters",
+ NULL },
+ { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "More verbose output",
+ NULL },
+ { "ip", 'i', 0, G_OPTION_ARG_STRING, &ip,
+ "Emulate that message was received from specified ip address",
+ NULL },
+ { "user", 'u', 0, G_OPTION_ARG_STRING, &user,
+ "Emulate that message was from specified user", NULL },
+ { "deliver", 'd', 0, G_OPTION_ARG_STRING, &deliver_to,
+ "Emulate that message is delivered to specified user", NULL },
+ { "from", 'F', 0, G_OPTION_ARG_STRING, &from,
+ "Emulate that message is from specified user", NULL },
+ { "rcpt", 'r', 0, G_OPTION_ARG_STRING, &rcpt,
+ "Emulate that message is for specified user", NULL },
+ { "helo", 0, 0, G_OPTION_ARG_STRING, &helo,
+ "Imitate SMTP HELO passing from MTA", NULL },
+ { "hostname", 0, 0, G_OPTION_ARG_STRING, &hostname,
+ "Imitate hostname passing from MTA", NULL },
+ { "timeout", 't', 0, G_OPTION_ARG_DOUBLE, &timeout,
+ "Time in seconds to wait for a reply", NULL },
+ { "bind", 'b', 0, G_OPTION_ARG_STRING, &local_addr,
+ "Bind to specified ip address", NULL },
+ { "commands", 0, 0, G_OPTION_ARG_NONE, &print_commands,
+ "List available commands", NULL },
+ { "json", 'j', 0, G_OPTION_ARG_NONE, &json, "Output json reply", NULL },
+ { "headers", 0, 0, G_OPTION_ARG_NONE, &headers, "Output HTTP headers",
+ NULL },
+ { "raw", 0, 0, G_OPTION_ARG_NONE, &raw, "Output raw reply from rspamd",
+ NULL },
+ { "max-requests", 'n', 0, G_OPTION_ARG_INT, &max_requests,
+ "Maximum count of parallel requests to rspamd", NULL },
+ { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
static void rspamc_symbols_output (ucl_object_t *obj);
.cmd = RSPAMC_COMMAND_FUZZY_ADD,
.name = "fuzzy_add",
.path = "fuzzyadd",
- .description = "add message to fuzzy storage (check -f and -w options for this command)",
+ .description =
+ "add message to fuzzy storage (check -f and -w options for this command)",
.is_controller = TRUE,
.is_privileged = TRUE,
.need_input = TRUE,
.cmd = RSPAMC_COMMAND_FUZZY_DEL,
.name = "fuzzy_del",
.path = "fuzzydel",
- .description = "delete message from fuzzy storage (check -f option for this command)",
+ .description =
+ "delete message from fuzzy storage (check -f option for this command)",
.is_controller = TRUE,
.is_privileged = TRUE,
.need_input = TRUE,
static void
read_cmd_line (gint *argc, gchar ***argv)
{
- GError *error = NULL;
- GOptionContext *context;
+ GError *error = NULL;
+ GOptionContext *context;
/* Prepare parser */
context = g_option_context_new ("- run rspamc client");
- g_option_context_set_summary (context, "Summary:\n Rspamd client version " RVERSION "\n Release id: " RID);
+ g_option_context_set_summary (context,
+ "Summary:\n Rspamd client version " RVERSION "\n Release id: " RID);
g_option_context_add_main_entries (context, entries, NULL);
/* Parse options */
ct = RSPAMC_COMMAND_ADD_ACTION;
}
- for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i ++) {
+ for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i++) {
if (rspamc_commands[i].cmd == ct) {
return &rspamc_commands[i];
}
static void
print_commands_list (void)
{
- guint i;
+ guint i;
rspamd_fprintf (stdout, "Rspamc commands summary:\n");
- for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i ++) {
- rspamd_fprintf (stdout, " %10s (%7s%1s)\t%s\n", rspamc_commands[i].name,
- rspamc_commands[i].is_controller ? "control" : "normal",
- rspamc_commands[i].is_privileged ? "*" : "",
- rspamc_commands[i].description);
- }
- rspamd_fprintf (stdout, "\n* is for privileged commands that may need password (see -P option)\n");
- rspamd_fprintf (stdout, "control commands use port 11334 while normal use 11333 by default (see -h option)\n");
+ for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i++) {
+ rspamd_fprintf (stdout,
+ " %10s (%7s%1s)\t%s\n",
+ rspamc_commands[i].name,
+ rspamc_commands[i].is_controller ? "control" : "normal",
+ rspamc_commands[i].is_privileged ? "*" : "",
+ rspamc_commands[i].description);
+ }
+ rspamd_fprintf (stdout,
+ "\n* is for privileged commands that may need password (see -P option)\n");
+ rspamd_fprintf (stdout,
+ "control commands use port 11334 while normal use 11333 by default (see -h option)\n");
}
while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
if (g_ascii_strcasecmp (ucl_object_key (cur), "is_spam") == 0) {
rspamd_fprintf (stdout, "Spam: %s\n", ucl_object_toboolean (cur) ?
- "true" : "false");
+ "true" : "false");
}
else if (g_ascii_strcasecmp (ucl_object_key (cur), "score") == 0) {
score = ucl_object_todouble (cur);
- got_scores ++;
+ got_scores++;
}
- else if (g_ascii_strcasecmp (ucl_object_key (cur), "required_score") == 0) {
+ else if (g_ascii_strcasecmp (ucl_object_key (cur),
+ "required_score") == 0) {
required_score = ucl_object_todouble (cur);
- got_scores ++;
+ got_scores++;
}
else if (g_ascii_strcasecmp (ucl_object_key (cur), "action") == 0) {
- rspamd_fprintf (stdout, "Action: %s\n", ucl_object_tostring(cur));
+ rspamd_fprintf (stdout, "Action: %s\n", ucl_object_tostring (cur));
}
else if (cur->type == UCL_OBJECT) {
rspamc_symbol_output (cur);
}
if (got_scores == 2) {
- rspamd_fprintf (stdout, "Score: %.2f / %.2f\n", score, required_score);
+ rspamd_fprintf (stdout,
+ "Score: %.2f / %.2f\n",
+ score,
+ required_score);
got_scores = 0;
}
}
while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
if (g_ascii_strcasecmp (ucl_object_key (cur), "message-id") == 0) {
- rspamd_fprintf (stdout, "Message-ID: %s\n", ucl_object_tostring (cur));
+ rspamd_fprintf (stdout, "Message-ID: %s\n", ucl_object_tostring (
+ cur));
}
else if (g_ascii_strcasecmp (ucl_object_key (cur), "queue-id") == 0) {
- rspamd_fprintf (stdout, "Queue-ID: %s\n", ucl_object_tostring (cur));
+ rspamd_fprintf (stdout, "Queue-ID: %s\n",
+ ucl_object_tostring (cur));
}
else if (g_ascii_strcasecmp (ucl_object_key (cur), "urls") == 0) {
emitted = ucl_object_emit (cur, UCL_EMIT_JSON_COMPACT);
free (emitted);
}
else if (g_ascii_strcasecmp (ucl_object_key (cur), "error") == 0) {
- rspamd_fprintf (stdout, "Scan error: %s\n", ucl_object_tostring (cur));
+ rspamd_fprintf (stdout, "Scan error: %s\n", ucl_object_tostring (
+ cur));
}
else if (cur->type == UCL_OBJECT) {
/* Parse metric */
elt = ucl_object_find_key (obj, "version");
if (elt != NULL) {
- rspamd_fprintf (stdout, "Rspamd version: %s\n", ucl_object_tostring (elt));
+ rspamd_fprintf (stdout, "Rspamd version: %s\n", ucl_object_tostring (
+ elt));
}
elt = ucl_object_find_key (obj, "uptime");
hours = seconds / 3600 - days * 24;
minutes = seconds / 60 - hours * 60 - days * 1440;
rspamd_printf ("%L day%s %L hour%s %L minute%s\n", days,
- days > 1 ? "s" : "", hours, hours > 1 ? "s" : "",
- minutes, minutes > 1 ? "s" : "");
+ days > 1 ? "s" : "", hours, hours > 1 ? "s" : "",
+ minutes, minutes > 1 ? "s" : "");
}
/* If uptime is less than 1 minute print only seconds */
else if (seconds / 60 == 0) {
rspamd_printf ("%L second%s\n", (gint)seconds,
- (gint)seconds > 1 ? "s" : "");
+ (gint)seconds > 1 ? "s" : "");
}
/* Else print the minutes and seconds. */
else {
minutes = seconds / 60 - hours * 60;
seconds -= hours * 3600 + minutes * 60;
rspamd_printf ("%L hour%s %L minute%s %L second%s\n", hours,
- hours > 1 ? "s" : "", minutes,
- minutes > 1 ? "s" : "",
- seconds, seconds > 1 ? "s" : "");
+ hours > 1 ? "s" : "", minutes,
+ minutes > 1 ? "s" : "",
+ seconds, seconds > 1 ? "s" : "");
}
}
}
}
rspamd_snprintf (fmt_buf, sizeof (fmt_buf),
- "| %%3s | %%%ds | %%6s | %%9s | %%9s |\n", max_len);
+ "| %%3s | %%%ds | %%6s | %%9s | %%9s |\n", max_len);
memset (dash_buf, '-', 40 + max_len);
dash_buf[40 + max_len] = '\0';
printf ("\033[0m");
}
rspamd_snprintf (fmt_buf, sizeof (fmt_buf),
- "| %%3d | %%%ds | %%6.1f | %%9d | %%9.3f |\n", max_len);
+ "| %%3d | %%%ds | %%6.1f | %%9d | %%9.3f |\n", max_len);
iter = NULL;
i = 0;
(gint)ucl_object_toint (freq),
ucl_object_todouble (tim));
}
- i ++;
+ i++;
}
printf (" %s \n", dash_buf);
}
{
struct rspamd_http_header *h;
- LL_FOREACH (msg->headers, h) {
+ LL_FOREACH (msg->headers, h)
+ {
rspamd_fprintf (stdout, "%v: %v\n", h->name, h->value);
}
rspamd_fprintf (stdout, "\n");
static void
rspamc_client_cb (struct rspamd_client_connection *conn,
- struct rspamd_http_message *msg,
- const gchar *name, ucl_object_t *result,
- gpointer ud, GError *err)
+ struct rspamd_http_message *msg,
+ const gchar *name, ucl_object_t *result,
+ gpointer ud, GError *err)
{
gchar *out;
struct rspamc_callback_data *cbdata = (struct rspamc_callback_data *)ud;
static void
rspamc_process_input (struct event_base *ev_base, struct rspamc_command *cmd,
- FILE *in, const gchar *name, GHashTable *attrs)
+ FILE *in, const gchar *name, GHashTable *attrs)
{
struct rspamd_client_connection *conn;
gchar **connectv;
guint16 port;
GError *err = NULL;
- struct rspamc_callback_data *cbdata;
+ struct rspamc_callback_data *cbdata;
connectv = g_strsplit_set (connect_str, ":", -1);
cbdata->filename = name;
if (cmd->need_input) {
rspamd_client_command (conn, cmd->path, attrs, in, rspamc_client_cb,
- cbdata, &err);
+ cbdata, &err);
}
else {
- rspamd_client_command (conn, cmd->path, attrs, NULL, rspamc_client_cb,
- cbdata, &err);
+ rspamd_client_command (conn,
+ cmd->path,
+ attrs,
+ NULL,
+ rspamc_client_cb,
+ cbdata,
+ &err);
}
}
}
gint
main (gint argc, gchar **argv, gchar **env)
{
- gint i, start_argc, cur_req = 0;
- GHashTable *kwattrs;
- struct rspamc_command *cmd;
- FILE *in = NULL;
- struct event_base *ev_base;
+ gint i, start_argc, cur_req = 0;
+ GHashTable *kwattrs;
+ struct rspamc_command *cmd;
+ FILE *in = NULL;
+ struct event_base *ev_base;
kwattrs = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
else {
if ((cmd = check_rspamc_command (argv[1])) != NULL) {
/* In case of command read arguments starting from 2 */
- if (cmd->cmd == RSPAMC_COMMAND_ADD_SYMBOL || cmd->cmd == RSPAMC_COMMAND_ADD_ACTION) {
+ if (cmd->cmd == RSPAMC_COMMAND_ADD_SYMBOL || cmd->cmd ==
+ RSPAMC_COMMAND_ADD_ACTION) {
if (argc < 4 || argc > 5) {
fprintf (stderr, "invalid arguments\n");
exit (EXIT_FAILURE);
}
if (argc == 5) {
g_hash_table_insert (kwattrs, "metric", argv[2]);
- g_hash_table_insert (kwattrs, "name", argv[3]);
- g_hash_table_insert (kwattrs, "value", argv[4]);
+ g_hash_table_insert (kwattrs, "name", argv[3]);
+ g_hash_table_insert (kwattrs, "value", argv[4]);
}
else {
- g_hash_table_insert (kwattrs, "name", argv[2]);
+ g_hash_table_insert (kwattrs, "name", argv[2]);
g_hash_table_insert (kwattrs, "value", argv[3]);
}
start_argc = argc;
rspamc_process_input (ev_base, cmd, in, "stdin", kwattrs);
}
else {
- for (i = start_argc; i < argc; i ++) {
+ for (i = start_argc; i < argc; i++) {
in = fopen (argv[i], "r");
if (in == NULL) {
fprintf (stderr, "cannot open file %s\n", argv[i]);
exit (EXIT_FAILURE);
}
rspamc_process_input (ev_base, cmd, in, argv[i], kwattrs);
- cur_req ++;
+ cur_req++;
fclose (in);
if (cur_req >= max_requests) {
cur_req = 0;
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "http.h"
#include "rspamdclient.h"
#include "util.h"
-#include "http.h"
#ifdef HAVE_FETCH_H
#include <fetch.h>
static gint
rspamd_client_body_handler (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg,
- const gchar *chunk, gsize len)
+ struct rspamd_http_message *msg,
+ const gchar *chunk, gsize len)
{
/* Do nothing here */
return 0;
static void
rspamd_client_error_handler (struct rspamd_http_connection *conn, GError *err)
{
- struct rspamd_client_request *req = (struct rspamd_client_request *)conn->ud;
+ struct rspamd_client_request *req =
+ (struct rspamd_client_request *)conn->ud;
struct rspamd_client_connection *c;
c = req->conn;
static gint
rspamd_client_finish_handler (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_client_request *req = (struct rspamd_client_request *)conn->ud;
+ struct rspamd_client_request *req =
+ (struct rspamd_client_request *)conn->ud;
struct rspamd_client_connection *c;
struct ucl_parser *parser;
GError *err;
if (!c->req_sent) {
c->req_sent = TRUE;
rspamd_http_connection_reset (c->http_conn);
- rspamd_http_connection_read_message (c->http_conn, c->req, c->fd, &c->timeout, c->ev_base);
+ rspamd_http_connection_read_message (c->http_conn,
+ c->req,
+ c->fd,
+ &c->timeout,
+ c->ev_base);
return 0;
}
else {
if (msg->body == NULL || msg->body->len == 0 || msg->code != 200) {
err = g_error_new (RCLIENT_ERROR, msg->code, "HTTP error: %d, %s",
- msg->code, msg->status ? msg->status->str : "unknown error");
+ msg->code,
+ msg->status ? msg->status->str : "unknown error");
req->cb (c, msg, c->server_name->str, NULL, req->ud, err);
g_error_free (err);
return -1;
return -1;
}
- req->cb (c, msg, c->server_name->str, ucl_parser_get_object (parser), req->ud, NULL);
+ req->cb (c, msg, c->server_name->str, ucl_parser_get_object (
+ parser), req->ud, NULL);
ucl_parser_free (parser);
}
struct rspamd_client_connection *
rspamd_client_init (struct event_base *ev_base, const gchar *name,
- guint16 port, gdouble timeout)
+ guint16 port, gdouble timeout)
{
struct rspamd_client_connection *conn;
gint fd;
conn->fd = fd;
conn->req_sent = FALSE;
conn->http_conn = rspamd_http_connection_new (rspamd_client_body_handler,
- rspamd_client_error_handler, rspamd_client_finish_handler, 0, RSPAMD_HTTP_CLIENT);
+ rspamd_client_error_handler,
+ rspamd_client_finish_handler,
+ 0,
+ RSPAMD_HTTP_CLIENT);
conn->server_name = g_string_new (name);
if (port != 0) {
rspamd_printf_gstring (conn->server_name, ":%d", (int)port);
gboolean
rspamd_client_command (struct rspamd_client_connection *conn,
- const gchar *command, GHashTable *attrs,
- FILE *in, rspamd_client_callback cb,
- gpointer ud, GError **err)
+ const gchar *command, GHashTable *attrs,
+ FILE *in, rspamd_client_callback cb,
+ gpointer ud, GError **err)
{
struct rspamd_client_request *req;
gchar *p, *hn, *hv;
}
}
if (ferror (in) != 0) {
- g_set_error (err, RCLIENT_ERROR, ferror (in), "input IO error: %s", strerror (ferror (in)));
+ g_set_error (err, RCLIENT_ERROR, ferror (
+ in), "input IO error: %s", strerror (ferror (in)));
g_slice_free1 (sizeof (struct rspamd_client_request), req);
return FALSE;
}
conn->req = req;
rspamd_http_connection_write_message (conn->http_conn, req->msg, NULL,
- "text/plain", req, conn->fd, &conn->timeout, conn->ev_base);
+ "text/plain", req, conn->fd, &conn->timeout, conn->ev_base);
return TRUE;
}
* @param err error pointer
*/
typedef void (*rspamd_client_callback) (
- struct rspamd_client_connection *conn,
- struct rspamd_http_message *msg,
- const gchar *name,
- ucl_object_t *result,
- gpointer ud,
- GError *err);
+ struct rspamd_client_connection *conn,
+ struct rspamd_http_message *msg,
+ const gchar *name,
+ ucl_object_t *result,
+ gpointer ud,
+ GError *err);
/**
* Start rspamd worker or controller command
* @param timeout timeout in seconds
* @return
*/
-struct rspamd_client_connection* rspamd_client_init (
- struct event_base *ev_base,
- const gchar *name,
- guint16 port,
- gdouble timeout);
+struct rspamd_client_connection * rspamd_client_init (
+ struct event_base *ev_base,
+ const gchar *name,
+ guint16 port,
+ gdouble timeout);
/**
*
* @return
*/
gboolean rspamd_client_command (
- struct rspamd_client_connection *conn,
- const gchar *command,
- GHashTable *attrs,
- FILE *in,
- rspamd_client_callback cb,
- gpointer ud,
- GError **err);
+ struct rspamd_client_connection *conn,
+ const gchar *command,
+ GHashTable *attrs,
+ FILE *in,
+ rspamd_client_callback cb,
+ gpointer ud,
+ GError **err);
/**
* Destroy a connection to rspamd
*/
+#include "cfg_file.h"
+#include "classifiers/classifiers.h"
#include "config.h"
-#include "util.h"
-#include "main.h"
+#include "dns.h"
+#include "dynamic_cfg.h"
#include "http.h"
+#include "main.h"
+#include "map.h"
#include "message.h"
#include "protocol.h"
-#include "upstream.h"
-#include "cfg_file.h"
-#include "map.h"
-#include "dns.h"
-#include "tokenizers/tokenizers.h"
-#include "classifiers/classifiers.h"
-#include "dynamic_cfg.h"
#include "rrd.h"
+#include "tokenizers/tokenizers.h"
+#include "upstream.h"
+#include "util.h"
#ifdef WITH_GPERF_TOOLS
# include <glib/gprintf.h>
void start_controller_worker (struct rspamd_worker *worker);
worker_t controller_worker = {
- "controller", /* Name */
- init_controller_worker, /* Init function */
- start_controller_worker, /* Start function */
- TRUE, /* Has socket */
- TRUE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE, /* Killable */
- SOCK_STREAM /* TCP socket */
+ "controller", /* Name */
+ init_controller_worker, /* Init function */
+ start_controller_worker, /* Start function */
+ TRUE, /* Has socket */
+ TRUE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE, /* Killable */
+ SOCK_STREAM /* TCP socket */
};
/*
* Worker's context
*/
struct rspamd_controller_worker_ctx {
- guint32 timeout;
- struct timeval io_tv;
+ guint32 timeout;
+ struct timeval io_tv;
/* DNS resolver */
- struct rspamd_dns_resolver *resolver;
+ struct rspamd_dns_resolver *resolver;
/* Events base */
- struct event_base *ev_base;
+ struct event_base *ev_base;
/* Whether we use ssl for this server */
gboolean use_ssl;
/* Webui password */
/* Check for password if it is required by configuration */
static gboolean
rspamd_controller_check_password (struct rspamd_http_connection_entry *entry,
- struct rspamd_controller_session *session, struct rspamd_http_message *msg,
- gboolean is_enable)
+ struct rspamd_controller_session *session, struct rspamd_http_message *msg,
+ gboolean is_enable)
{
- const gchar *password, *check;
- struct rspamd_controller_worker_ctx *ctx = session->ctx;
+ const gchar *password, *check;
+ struct rspamd_controller_worker_ctx *ctx = session->ctx;
gboolean ret = TRUE;
/* Access list logic */
return TRUE;
}
else if (ctx->secure_map && radix32_tree_find_addr (ctx->secure_map,
- &session->from_addr) != RADIX_NO_VALUE) {
+ &session->from_addr) != RADIX_NO_VALUE) {
msg_info ("allow unauthorized connection from a trusted IP %s",
- rspamd_inet_address_to_string (&session->from_addr));
+ rspamd_inet_address_to_string (&session->from_addr));
return TRUE;
}
password = rspamd_http_message_find_header (msg, "Password");
if (ctx->enable_password == NULL) {
/* Use just a password (legacy mode) */
- msg_info ("using password as enable_password for a privileged command");
+ msg_info (
+ "using password as enable_password for a privileged command");
check = ctx->password;
}
else {
}
}
else {
- msg_warn ("no password to check while executing a privileged command");
+ msg_warn (
+ "no password to check while executing a privileged command");
if (ctx->secure_map) {
msg_info ("deny unauthorized connection");
ret = FALSE;
*/
static int
rspamd_controller_handle_auth (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct rspamd_stat *st;
- int64_t uptime;
- gulong data[4];
- ucl_object_t *obj;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_stat *st;
+ int64_t uptime;
+ gulong data[4];
+ ucl_object_t *obj;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
return 0;
obj = ucl_object_typed_new (UCL_OBJECT);
st = session->ctx->srv->stat;
data[0] = st->actions_stat[METRIC_ACTION_NOACTION];
- data[1] = st->actions_stat[METRIC_ACTION_ADD_HEADER] + st->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
+ data[1] = st->actions_stat[METRIC_ACTION_ADD_HEADER] +
+ st->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
data[2] = st->actions_stat[METRIC_ACTION_GREYLIST];
data[3] = st->actions_stat[METRIC_ACTION_REJECT];
/* Get uptime */
uptime = time (NULL) - session->ctx->start_time;
- ucl_object_insert_key (obj, ucl_object_fromstring (RVERSION), "version", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromstring ("ok"), "auth", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (uptime), "uptime", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (data[0]), "clean", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (data[1]), "probable", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (data[2]), "greylist", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (data[3]), "reject", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (st->messages_scanned), "scanned", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (st->messages_learned), "learned", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ RVERSION), "version", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ "ok"), "auth", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ uptime), "uptime", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ data[0]), "clean", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ data[1]), "probable", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ data[2]), "greylist", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ data[3]), "reject", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ st->messages_scanned), "scanned", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ st->messages_learned), "learned", 0, false);
rspamd_controller_send_ucl (conn_ent, obj);
ucl_object_unref (obj);
* Symbols command handler:
* request: /symbols
* reply: json [{
- * "name": "group_name",
- * "symbols": [
- * {
- * "name": "name",
- * "weight": 0.1,
- * "description": "description of symbol"
- * },
- * {...}
+ * "name": "group_name",
+ * "symbols": [
+ * {
+ * "name": "name",
+ * "weight": 0.1,
+ * "description": "description of symbol"
+ * },
+ * {...}
* },
* {...}]
*/
static int
rspamd_controller_handle_symbols (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- GList *cur_gr, *cur_sym;
- struct rspamd_symbols_group *gr;
- struct rspamd_symbol_def *sym;
- ucl_object_t *obj, *top, *sym_obj;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ GList *cur_gr, *cur_sym;
+ struct rspamd_symbols_group *gr;
+ struct rspamd_symbol_def *sym;
+ ucl_object_t *obj, *top, *sym_obj;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
return 0;
while (cur_gr) {
gr = cur_gr->data;
obj = ucl_object_typed_new (UCL_OBJECT);
- ucl_object_insert_key (obj, ucl_object_fromstring (gr->name), "group", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ gr->name), "group", 0, false);
/* Iterate through all symbols */
cur_sym = gr->symbols;
while (cur_sym) {
sym = cur_sym->data;
ucl_object_insert_key (sym_obj, ucl_object_fromstring (sym->name),
- "symbol", 0, false);
- ucl_object_insert_key (sym_obj, ucl_object_fromdouble (*sym->weight_ptr),
- "weight", 0, false);
+ "symbol", 0, false);
+ ucl_object_insert_key (sym_obj,
+ ucl_object_fromdouble (*sym->weight_ptr),
+ "weight", 0, false);
if (sym->description) {
- ucl_object_insert_key (sym_obj, ucl_object_fromstring (sym->description),
+ ucl_object_insert_key (sym_obj,
+ ucl_object_fromstring (sym->description),
"description", 0, false);
}
* Actions command handler:
* request: /actions
* reply: json [{
- * "action": "no action",
- * "value": 1.1
+ * "action": "no action",
+ * "value": 1.1
* },
* {...}]
*/
static int
rspamd_controller_handle_actions (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct metric *metric;
- struct metric_action *act;
- gint i;
- ucl_object_t *obj, *top;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct metric *metric;
+ struct metric_action *act;
+ gint i;
+ ucl_object_t *obj, *top;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
return 0;
/* Get actions for default metric */
metric = g_hash_table_lookup (session->ctx->cfg->metrics, DEFAULT_METRIC);
if (metric != NULL) {
- for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
+ for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
act = &metric->actions[i];
if (act->score > 0) {
obj = ucl_object_typed_new (UCL_OBJECT);
ucl_object_insert_key (obj,
- ucl_object_fromstring (str_action_metric (act->action)), "action", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromdouble (act->score), "value", 0, false);
+ ucl_object_fromstring (str_action_metric (
+ act->action)), "action", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromdouble (
+ act->score), "value", 0, false);
ucl_array_append (top, obj);
}
}
* request: /maps
* headers: Password
* reply: json [
- * {
- * "map": "name",
- * "description": "description",
- * "editable": true
- * },
- * {...}
+ * {
+ * "map": "name",
+ * "description": "description",
+ * "editable": true
+ * },
+ * {...}
* ]
*/
static int
rspamd_controller_handle_maps (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- GList *cur, *tmp = NULL;
- struct rspamd_map *map;
- gboolean editable;
- ucl_object_t *obj, *top;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ GList *cur, *tmp = NULL;
+ struct rspamd_map *map;
+ gboolean editable;
+ ucl_object_t *obj, *top;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
editable = (access (map->uri, W_OK) == 0);
obj = ucl_object_typed_new (UCL_OBJECT);
- ucl_object_insert_key (obj, ucl_object_fromint (map->id),
- "map", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (map->id),
+ "map", 0, false);
ucl_object_insert_key (obj, ucl_object_fromstring (map->description),
- "description", 0, false);
- ucl_object_insert_key (obj, ucl_object_frombool (editable),
- "editable", 0, false);
+ "description", 0, false);
+ ucl_object_insert_key (obj, ucl_object_frombool (editable),
+ "editable", 0, false);
ucl_array_append (top, obj);
cur = g_list_next (cur);
*/
static int
rspamd_controller_handle_get_map (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- GList *cur;
- struct rspamd_map *map;
- const gchar *idstr;
- gchar *errstr;
- struct stat st;
- gint fd;
- guint32 id;
- gboolean found = FALSE;
- struct rspamd_http_message *reply;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ GList *cur;
+ struct rspamd_map *map;
+ const gchar *idstr;
+ gchar *errstr;
+ struct stat st;
+ gint fd;
+ guint32 id;
+ gboolean found = FALSE;
+ struct rspamd_http_message *reply;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
rspamd_http_connection_reset (conn_ent->conn);
rspamd_http_connection_write_message (conn_ent->conn, reply, NULL,
- "text/plain", conn_ent, conn_ent->conn->fd,
- conn_ent->rt->ptv, conn_ent->rt->ev_base);
+ "text/plain", conn_ent, conn_ent->conn->fd,
+ conn_ent->rt->ptv, conn_ent->rt->ev_base);
conn_ent->is_reply = TRUE;
return 0;
* request: /graph
* headers: Password
* reply: json [
- * { label: "Foo", data: [ [10, 1], [17, -14], [30, 5] ] },
- * { label: "Bar", data: [ [10, 1], [17, -14], [30, 5] ] },
- * {...}
+ * { label: "Foo", data: [ [10, 1], [17, -14], [30, 5] ] },
+ * { label: "Bar", data: [ [10, 1], [17, -14], [30, 5] ] },
+ * {...}
* ]
*/
/* XXX: now this function returns only random data */
static void
rspamd_controller_handle_graph (struct evhttp_request *req, gpointer arg)
{
- struct rspamd_controller_worker_ctx *ctx = arg;
- struct evbuffer *evb;
- gint i, seed;
- time_t now, t;
- double vals[5][100];
+ struct rspamd_controller_worker_ctx *ctx = arg;
+ struct evbuffer *evb;
+ gint i, seed;
+ time_t now, t;
+ double vals[5][100];
if (!http_check_password (ctx, req)) {
return;
/* XXX: simple and stupid set */
seed = g_random_int ();
- for (i = 0; i < 100; i ++, seed ++) {
- vals[0][i] = fabs ((sin (seed * 0.1 * M_PI_2) + 1) * 40. + ((gint)(g_random_int () % 2) - 1));
+ for (i = 0; i < 100; i++, seed++) {
+ vals[0][i] =
+ fabs ((sin (seed * 0.1 *
+ M_PI_2) + 1) * 40. + ((gint)(g_random_int () % 2) - 1));
vals[1][i] = vals[0][i] * 0.5;
vals[2][i] = vals[0][i] * 0.1;
vals[3][i] = vals[0][i] * 0.3;
/* Ham label */
t = now - 6000;
- evbuffer_add_printf (evb, "{\"label\": \"Clean messages\", \"lines\": {\"fill\": false}, \"color\": \""
- COLOR_CLEAN "\", \"data\":[");
- for (i = 0; i < 100; i ++, t += 60) {
- evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[0][i], i == 99 ? "]" : "],");
+ evbuffer_add_printf (evb,
+ "{\"label\": \"Clean messages\", \"lines\": {\"fill\": false}, \"color\": \""
+ COLOR_CLEAN "\", \"data\":[");
+ for (i = 0; i < 100; i++, t += 60) {
+ evbuffer_add_printf (evb,
+ "[%llu,%.2f%s",
+ (long long unsigned)t * 1000,
+ vals[0][i],
+ i == 99 ? "]" : "],");
}
evbuffer_add (evb, "]},", 3);
/* Probable spam label */
t = now - 6000;
- evbuffer_add_printf (evb, "{\"label\": \"Probable spam messages\", \"lines\": {\"fill\": false}, \"color\": \""
- COLOR_PROBABLE_SPAM "\", \"data\":[");
- for (i = 0; i < 100; i ++, t += 60) {
- evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[1][i], i == 99 ? "]" : "],");
+ evbuffer_add_printf (evb,
+ "{\"label\": \"Probable spam messages\", \"lines\": {\"fill\": false}, \"color\": \""
+ COLOR_PROBABLE_SPAM "\", \"data\":[");
+ for (i = 0; i < 100; i++, t += 60) {
+ evbuffer_add_printf (evb,
+ "[%llu,%.2f%s",
+ (long long unsigned)t * 1000,
+ vals[1][i],
+ i == 99 ? "]" : "],");
}
evbuffer_add (evb, "]},", 3);
/* Greylist label */
t = now - 6000;
- evbuffer_add_printf (evb, "{\"label\": \"Greylisted messages\", \"lines\": {\"fill\": false}, \"color\": \""
- COLOR_GREYLIST "\", \"data\":[");
- for (i = 0; i < 100; i ++, t += 60) {
- evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[2][i], i == 99 ? "]" : "],");
+ evbuffer_add_printf (evb,
+ "{\"label\": \"Greylisted messages\", \"lines\": {\"fill\": false}, \"color\": \""
+ COLOR_GREYLIST "\", \"data\":[");
+ for (i = 0; i < 100; i++, t += 60) {
+ evbuffer_add_printf (evb,
+ "[%llu,%.2f%s",
+ (long long unsigned)t * 1000,
+ vals[2][i],
+ i == 99 ? "]" : "],");
}
evbuffer_add (evb, "]},", 3);
/* Reject label */
t = now - 6000;
- evbuffer_add_printf (evb, "{\"label\": \"Rejected messages\", \"lines\": {\"fill\": false}, \"color\": \""
- COLOR_REJECT "\", \"data\":[");
- for (i = 0; i < 100; i ++, t += 60) {
- evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[3][i], i == 99 ? "]" : "],");
+ evbuffer_add_printf (evb,
+ "{\"label\": \"Rejected messages\", \"lines\": {\"fill\": false}, \"color\": \""
+ COLOR_REJECT "\", \"data\":[");
+ for (i = 0; i < 100; i++, t += 60) {
+ evbuffer_add_printf (evb,
+ "[%llu,%.2f%s",
+ (long long unsigned)t * 1000,
+ vals[3][i],
+ i == 99 ? "]" : "],");
}
evbuffer_add (evb, "]},", 3);
/* Total label */
t = now - 6000;
- evbuffer_add_printf (evb, "{\"label\": \"Total messages\", \"lines\": {\"fill\": false}, \"color\": \""
- COLOR_TOTAL "\", \"data\":[");
- for (i = 0; i < 100; i ++, t += 60) {
- evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[4][i], i == 99 ? "]" : "],");
+ evbuffer_add_printf (evb,
+ "{\"label\": \"Total messages\", \"lines\": {\"fill\": false}, \"color\": \""
+ COLOR_TOTAL "\", \"data\":[");
+ for (i = 0; i < 100; i++, t += 60) {
+ evbuffer_add_printf (evb,
+ "[%llu,%.2f%s",
+ (long long unsigned)t * 1000,
+ vals[4][i],
+ i == 99 ? "]" : "],");
}
- evbuffer_add (evb, "]}", 2);
+ evbuffer_add (evb, "]}", 2);
- evbuffer_add (evb, "]" CRLF, 3);
+ evbuffer_add (evb, "]" CRLF, 3);
evhttp_add_header (req->output_headers, "Connection", "close");
http_calculate_content_length (evb, req);
* request: /pie
* headers: Password
* reply: json [
- * { label: "Foo", data: 11 },
- * { label: "Bar", data: 20 },
- * {...}
+ * { label: "Foo", data: 11 },
+ * { label: "Bar", data: 20 },
+ * {...}
* ]
*/
static int
-rspamd_controller_handle_pie_chart (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_pie_chart (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct rspamd_controller_worker_ctx *ctx;
- gdouble data[4], total;
- ucl_object_t *top, *obj;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_worker_ctx *ctx;
+ gdouble data[4], total;
+ ucl_object_t *top, *obj;
ctx = session->ctx;
if (total != 0) {
obj = ucl_object_typed_new (UCL_ARRAY);
- data[0] = ctx->srv->stat->actions_stat[METRIC_ACTION_NOACTION] / total * 100.;
+ data[0] = ctx->srv->stat->actions_stat[METRIC_ACTION_NOACTION] / total *
+ 100.;
data[1] = (ctx->srv->stat->actions_stat[METRIC_ACTION_ADD_HEADER] +
- ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT]) / total * 100.;
- data[2] = ctx->srv->stat->actions_stat[METRIC_ACTION_GREYLIST] / total * 100.;
- data[3] = ctx->srv->stat->actions_stat[METRIC_ACTION_REJECT] / total * 100.;
+ ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT]) /
+ total * 100.;
+ data[2] = ctx->srv->stat->actions_stat[METRIC_ACTION_GREYLIST] / total *
+ 100.;
+ data[3] = ctx->srv->stat->actions_stat[METRIC_ACTION_REJECT] / total *
+ 100.;
ucl_array_append (obj, ucl_object_fromstring ("Clean messages"));
ucl_array_append (obj, ucl_object_fromdouble (data[0]));
- ucl_array_append (top, obj);
- ucl_array_append (obj, ucl_object_fromstring ("Probable spam messages"));
+ ucl_array_append (top, obj);
+ ucl_array_append (obj,
+ ucl_object_fromstring ("Probable spam messages"));
ucl_array_append (obj, ucl_object_fromdouble (data[1]));
- ucl_array_append (top, obj);
+ ucl_array_append (top, obj);
ucl_array_append (obj, ucl_object_fromstring ("Greylisted messages"));
ucl_array_append (obj, ucl_object_fromdouble (data[2]));
- ucl_array_append (top, obj);
+ ucl_array_append (top, obj);
ucl_array_append (obj, ucl_object_fromstring ("Rejected messages"));
ucl_array_append (obj, ucl_object_fromdouble (data[3]));
- ucl_array_append (top, obj);
+ ucl_array_append (top, obj);
}
else {
obj = ucl_object_typed_new (UCL_ARRAY);
ucl_array_append (obj, ucl_object_fromstring ("Scanned messages"));
ucl_array_append (obj, ucl_object_fromdouble (0));
- ucl_array_append (top, obj);
+ ucl_array_append (top, obj);
}
rspamd_controller_send_ucl (conn_ent, top);
* request: /history
* headers: Password
* reply: json [
- * { label: "Foo", data: 11 },
- * { label: "Bar", data: 20 },
- * {...}
+ * { label: "Foo", data: 11 },
+ * { label: "Bar", data: 20 },
+ * {...}
* ]
*/
static int
rspamd_controller_handle_history (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct rspamd_controller_worker_ctx *ctx;
- struct roll_history_row *row;
- struct roll_history copied_history;
- gint i, rows_proc, row_num;
- struct tm *tm;
- gchar timebuf[32];
- gchar ip_buf[INET6_ADDRSTRLEN];
- ucl_object_t *top, *obj;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_worker_ctx *ctx;
+ struct roll_history_row *row;
+ struct roll_history copied_history;
+ gint i, rows_proc, row_num;
+ struct tm *tm;
+ gchar timebuf[32];
+ gchar ip_buf[INET6_ADDRSTRLEN];
+ ucl_object_t *top, *obj;
ctx = session->ctx;
/* Go through all rows */
row_num = copied_history.cur_row;
- for (i = 0, rows_proc = 0; i < HISTORY_MAX_ROWS; i ++, row_num ++) {
+ for (i = 0, rows_proc = 0; i < HISTORY_MAX_ROWS; i++, row_num++) {
if (row_num == HISTORY_MAX_ROWS) {
row_num = 0;
}
strftime (timebuf, sizeof (timebuf), "%F %H:%M:%S", tm);
#ifdef HAVE_INET_PTON
if (row->from_addr.ipv6) {
- inet_ntop (AF_INET6, &row->from_addr.d.in6, ip_buf, sizeof (ip_buf));
+ inet_ntop (AF_INET6, &row->from_addr.d.in6, ip_buf,
+ sizeof (ip_buf));
}
else {
- inet_ntop (AF_INET, &row->from_addr.d.in4, ip_buf, sizeof (ip_buf));
+ inet_ntop (AF_INET, &row->from_addr.d.in4, ip_buf,
+ sizeof (ip_buf));
}
#else
- rspamd_strlcpy (ip_buf, inet_ntoa (task->from_addr), sizeof (ip_buf));
+ rspamd_strlcpy (ip_buf, inet_ntoa (task->from_addr),
+ sizeof (ip_buf));
#endif
obj = ucl_object_typed_new (UCL_OBJECT);
- ucl_object_insert_key (obj, ucl_object_fromstring (timebuf), "time", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromstring (row->message_id), "id", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromstring (ip_buf), "ip", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ timebuf), "time", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ row->message_id), "id", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ ip_buf), "ip", 0, false);
+ ucl_object_insert_key (obj,
+ ucl_object_fromstring (str_action_metric (
+ row->action)), "action", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromdouble (
+ row->score), "score", 0, false);
ucl_object_insert_key (obj,
- ucl_object_fromstring (str_action_metric (row->action)), "action", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromdouble (row->score), "score", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromdouble (row->required_score), "required_score", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromstring (row->symbols), "symbols", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (row->len), "size", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (row->scan_time), "scan_time", 0, false);
+ ucl_object_fromdouble (
+ row->required_score), "required_score", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ row->symbols), "symbols", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ row->len), "size", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ row->scan_time), "scan_time", 0, false);
if (row->user[0] != '\0') {
- ucl_object_insert_key (obj, ucl_object_fromstring (row->user), "user", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ row->user), "user", 0, false);
}
ucl_array_append (top, obj);
- rows_proc ++;
+ rows_proc++;
}
}
static gboolean
rspamd_controller_learn_fin_task (void *ud)
{
- struct rspamd_task *task = ud;
- struct rspamd_controller_session *session;
- struct rspamd_http_connection_entry *conn_ent;
- GError *err = NULL;
+ struct rspamd_task *task = ud;
+ struct rspamd_controller_session *session;
+ struct rspamd_http_connection_entry *conn_ent;
+ GError *err = NULL;
conn_ent = task->fin_arg;
session = conn_ent->ud;
static gboolean
rspamd_controller_check_fin_task (void *ud)
{
- struct rspamd_task *task = ud;
- struct rspamd_http_connection_entry *conn_ent;
+ struct rspamd_task *task = ud;
+ struct rspamd_http_connection_entry *conn_ent;
struct rspamd_http_message *msg;
conn_ent = task->fin_arg;
rspamd_protocol_http_reply (msg, task);
rspamd_http_connection_reset (conn_ent->conn);
rspamd_http_connection_write_message (conn_ent->conn, msg, NULL,
- "application/json", conn_ent, conn_ent->conn->fd, conn_ent->rt->ptv,
- conn_ent->rt->ev_base);
+ "application/json", conn_ent, conn_ent->conn->fd, conn_ent->rt->ptv,
+ conn_ent->rt->ev_base);
conn_ent->is_reply = TRUE;
return TRUE;
}
static int
-rspamd_controller_handle_learn_common (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg, gboolean is_spam)
+rspamd_controller_handle_learn_common (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg,
+ gboolean is_spam)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct rspamd_controller_worker_ctx *ctx;
- struct rspamd_classifier_config *cl;
- struct rspamd_task *task;
- const gchar *classifier;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_worker_ctx *ctx;
+ struct rspamd_classifier_config *cl;
+ struct rspamd_task *task;
+ const gchar *classifier;
ctx = session->ctx;
if (msg->body == NULL || msg->body->len == 0) {
msg_err ("got zero length body, cannot continue");
- rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
+ rspamd_controller_send_error (conn_ent,
+ 400,
+ "Empty body is not permitted");
return 0;
}
- if ((classifier = rspamd_http_message_find_header (msg, "Classifier")) == NULL) {
+ if ((classifier =
+ rspamd_http_message_find_header (msg, "Classifier")) == NULL) {
classifier = "bayes";
}
task->ev_base = ctx->ev_base;
- task->s = new_async_session (session->pool, rspamd_controller_learn_fin_task, NULL,
- rspamd_task_free_hard, task);
+ task->s = new_async_session (session->pool,
+ rspamd_controller_learn_fin_task,
+ NULL,
+ rspamd_task_free_hard,
+ task);
task->s->wanna_die = TRUE;
task->fin_arg = conn_ent;
task->http_conn = rspamd_http_connection_ref (conn_ent->conn);;
* reply: json {"success":true} or {"error":"error message"}
*/
static int
-rspamd_controller_handle_learnspam (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_learnspam (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
return rspamd_controller_handle_learn_common (conn_ent, msg, TRUE);
}
* reply: json {"success":true} or {"error":"error message"}
*/
static int
-rspamd_controller_handle_learnham (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_learnham (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
return rspamd_controller_handle_learn_common (conn_ent, msg, TRUE);
}
*/
static int
rspamd_controller_handle_scan (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct rspamd_controller_worker_ctx *ctx;
- struct rspamd_task *task;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_worker_ctx *ctx;
+ struct rspamd_task *task;
ctx = session->ctx;
if (msg->body == NULL || msg->body->len == 0) {
msg_err ("got zero length body, cannot continue");
- rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
+ rspamd_controller_send_error (conn_ent,
+ 400,
+ "Empty body is not permitted");
return 0;
}
task->resolver = ctx->resolver;
task->ev_base = ctx->ev_base;
- task->s = new_async_session (session->pool, rspamd_controller_check_fin_task, NULL,
- rspamd_task_free_hard, task);
+ task->s = new_async_session (session->pool,
+ rspamd_controller_check_fin_task,
+ NULL,
+ rspamd_task_free_hard,
+ task);
task->s->wanna_die = TRUE;
task->fin_arg = conn_ent;
task->http_conn = rspamd_http_connection_ref (conn_ent->conn);
* reply: json {"success":true} or {"error":"error message"}
*/
static int
-rspamd_controller_handle_saveactions (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_saveactions (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct ucl_parser *parser;
- struct metric *metric;
- ucl_object_t *obj, *cur;
- struct rspamd_controller_worker_ctx *ctx;
- const gchar *error;
- gdouble score;
- gint i;
- enum rspamd_metric_action act;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct ucl_parser *parser;
+ struct metric *metric;
+ ucl_object_t *obj, *cur;
+ struct rspamd_controller_worker_ctx *ctx;
+ const gchar *error;
+ gdouble score;
+ gint i;
+ enum rspamd_metric_action act;
ctx = session->ctx;
if (msg->body == NULL || msg->body->len == 0) {
msg_err ("got zero length body, cannot continue");
- rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
+ rspamd_controller_send_error (conn_ent,
+ 400,
+ "Empty body is not permitted");
return 0;
}
metric = g_hash_table_lookup (ctx->cfg->metrics, DEFAULT_METRIC);
if (metric == NULL) {
msg_err ("cannot find default metric");
- rspamd_controller_send_error (conn_ent, 500, "Default metric is absent");
+ rspamd_controller_send_error (conn_ent, 500,
+ "Default metric is absent");
return 0;
}
/* Now check for dynamic config */
if (!ctx->cfg->dynamic_conf) {
msg_err ("dynamic conf has not been defined");
- rspamd_controller_send_error (conn_ent, 500, "No dynamic_rules setting defined");
+ rspamd_controller_send_error (conn_ent,
+ 500,
+ "No dynamic_rules setting defined");
return 0;
}
}
cur = obj->value.av;
- for (i = 0; i < 3 && cur != NULL; i ++, cur = cur->next) {
- switch(i) {
+ for (i = 0; i < 3 && cur != NULL; i++, cur = cur->next) {
+ switch (i) {
case 0:
act = METRIC_ACTION_REJECT;
break;
* reply: json {"success":true} or {"error":"error message"}
*/
static int
-rspamd_controller_handle_savesymbols (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_savesymbols (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct ucl_parser *parser;
- struct metric *metric;
- ucl_object_t *obj;
- const ucl_object_t *cur, *jname, *jvalue;
- ucl_object_iter_t iter = NULL;
- struct rspamd_controller_worker_ctx *ctx;
- const gchar *error;
- gdouble val;
- struct symbol *sym;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct ucl_parser *parser;
+ struct metric *metric;
+ ucl_object_t *obj;
+ const ucl_object_t *cur, *jname, *jvalue;
+ ucl_object_iter_t iter = NULL;
+ struct rspamd_controller_worker_ctx *ctx;
+ const gchar *error;
+ gdouble val;
+ struct symbol *sym;
ctx = session->ctx;
if (msg->body == NULL || msg->body->len == 0) {
msg_err ("got zero length body, cannot continue");
- rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
+ rspamd_controller_send_error (conn_ent,
+ 400,
+ "Empty body is not permitted");
return 0;
}
metric = g_hash_table_lookup (ctx->cfg->metrics, DEFAULT_METRIC);
if (metric == NULL) {
msg_err ("cannot find default metric");
- rspamd_controller_send_error (conn_ent, 500, "Default metric is absent");
+ rspamd_controller_send_error (conn_ent, 500,
+ "Default metric is absent");
return 0;
}
/* Now check for dynamic config */
if (!ctx->cfg->dynamic_conf) {
msg_err ("dynamic conf has not been defined");
- rspamd_controller_send_error (conn_ent, 500, "No dynamic_rules setting defined");
+ rspamd_controller_send_error (conn_ent,
+ 500,
+ "No dynamic_rules setting defined");
return 0;
}
jname = ucl_object_find_key (cur, "name");
jvalue = ucl_object_find_key (cur, "value");
val = ucl_object_todouble (jvalue);
- sym = g_hash_table_lookup (metric->symbols, ucl_object_tostring (jname));
+ sym =
+ g_hash_table_lookup (metric->symbols, ucl_object_tostring (jname));
if (sym && fabs (sym->score - val) > 0.01) {
if (!add_dynamic_symbol (ctx->cfg, DEFAULT_METRIC,
- ucl_object_tostring (jname), val)) {
- msg_err ("add symbol failed for %s", ucl_object_tostring (jname));
- rspamd_controller_send_error (conn_ent, 506, "Add symbol failed");
+ ucl_object_tostring (jname), val)) {
+ msg_err ("add symbol failed for %s",
+ ucl_object_tostring (jname));
+ rspamd_controller_send_error (conn_ent, 506,
+ "Add symbol failed");
ucl_object_unref (obj);
return 0;
}
*/
static int
rspamd_controller_handle_savemap (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- GList *cur;
- struct rspamd_map *map;
- struct rspamd_controller_worker_ctx *ctx;
- const gchar *idstr;
- gchar *errstr;
- guint32 id;
- gboolean found = FALSE;
- gint fd;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ GList *cur;
+ struct rspamd_map *map;
+ struct rspamd_controller_worker_ctx *ctx;
+ const gchar *idstr;
+ gchar *errstr;
+ guint32 id;
+ gboolean found = FALSE;
+ gint fd;
ctx = session->ctx;
if (msg->body == NULL || msg->body->len == 0) {
msg_err ("got zero length body, cannot continue");
- rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
+ rspamd_controller_send_error (conn_ent,
+ 400,
+ "Empty body is not permitted");
return 0;
}
* reply: json data
*/
static int
-rspamd_controller_handle_stat_common (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg, gboolean do_reset)
+rspamd_controller_handle_stat_common (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg,
+ gboolean do_reset)
{
struct rspamd_controller_session *session = conn_ent->ud;
ucl_object_t *top, *sub;
stat = &stat_copy;
top = ucl_object_typed_new (UCL_OBJECT);
- ucl_object_insert_key (top, ucl_object_fromint (stat->messages_scanned), "scanned", 0, false);
+ ucl_object_insert_key (top, ucl_object_fromint (
+ stat->messages_scanned), "scanned", 0, false);
if (stat->messages_scanned > 0) {
sub = ucl_object_typed_new (UCL_OBJECT);
- for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i ++) {
+ for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
ucl_object_insert_key (sub,
- ucl_object_fromint (stat->actions_stat[i]),
- str_action_metric (i), 0, false);
+ ucl_object_fromint (stat->actions_stat[i]),
+ str_action_metric (i), 0, false);
if (i < METRIC_ACTION_GREYLIST) {
spam += stat->actions_stat[i];
}
ucl_object_insert_key (top, sub, "actions", 0, false);
}
- ucl_object_insert_key (top, ucl_object_fromint (spam), "spam_count", 0, false);
- ucl_object_insert_key (top, ucl_object_fromint (ham), "ham_count", 0, false);
+ ucl_object_insert_key (top, ucl_object_fromint (
+ spam), "spam_count", 0, false);
+ ucl_object_insert_key (top, ucl_object_fromint (
+ ham), "ham_count", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (stat->messages_learned), "learned", 0, false);
+ ucl_object_fromint (stat->messages_learned), "learned", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (stat->connections_count), "connections", 0, false);
+ ucl_object_fromint (stat->connections_count), "connections", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (stat->control_connections_count),
- "control_connections", 0, false);
+ ucl_object_fromint (stat->control_connections_count),
+ "control_connections", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.pools_allocated), "pools_allocated", 0, false);
+ ucl_object_fromint (mem_st.pools_allocated), "pools_allocated", 0,
+ false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.pools_freed), "pools_freed", 0, false);
+ ucl_object_fromint (mem_st.pools_freed), "pools_freed", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.bytes_allocated), "bytes_allocated", 0, false);
+ ucl_object_fromint (mem_st.bytes_allocated), "bytes_allocated", 0,
+ false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.chunks_allocated), "chunks_allocated", 0, false);
+ ucl_object_fromint (
+ mem_st.chunks_allocated), "chunks_allocated", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.shared_chunks_allocated),
- "shared_chunks_allocated", 0, false);
+ ucl_object_fromint (mem_st.shared_chunks_allocated),
+ "shared_chunks_allocated", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.chunks_freed), "chunks_freed", 0, false);
+ ucl_object_fromint (mem_st.chunks_freed), "chunks_freed", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (mem_st.oversized_chunks), "chunks_oversized", 0, false);
+ ucl_object_fromint (
+ mem_st.oversized_chunks), "chunks_oversized", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (stat->fuzzy_hashes), "fuzzy_stored", 0, false);
+ ucl_object_fromint (stat->fuzzy_hashes), "fuzzy_stored", 0, false);
ucl_object_insert_key (top,
- ucl_object_fromint (stat->fuzzy_hashes_expired), "fuzzy_expired", 0, false);
+ ucl_object_fromint (
+ stat->fuzzy_hashes_expired), "fuzzy_expired", 0, false);
/* Now write statistics for each statfile */
cur_cl = g_list_first (session->ctx->cfg->classifiers);
cur_st = g_list_first (ccf->statfiles);
while (cur_st) {
st = cur_st->data;
- if ((statfile = statfile_pool_is_open (session->ctx->srv->statfile_pool,
- st->path)) == NULL) {
+ if ((statfile =
+ statfile_pool_is_open (session->ctx->srv->statfile_pool,
+ st->path)) == NULL) {
statfile = statfile_pool_open (session->ctx->srv->statfile_pool,
st->path, st->size, FALSE);
}
total = statfile_get_total_blocks (statfile);
statfile_get_revision (statfile, &rev, &ti);
ucl_object_insert_key (obj,
- ucl_object_fromstring (st->symbol), "symbol", 0, false);
+ ucl_object_fromstring (st->symbol), "symbol", 0, false);
if (st->label != NULL) {
ucl_object_insert_key (obj,
- ucl_object_fromstring (st->label), "label", 0, false);
+ ucl_object_fromstring (st->label), "label", 0, false);
}
- ucl_object_insert_key (obj, ucl_object_fromint (rev), "revision", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (used), "used", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (total), "total", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ rev), "revision", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ used), "used", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (
+ total), "total", 0, false);
ucl_array_append (sub, obj);
}
static int
rspamd_controller_handle_stat (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_session *session = conn_ent->ud;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
return 0;
}
static int
-rspamd_controller_handle_statreset (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_statreset (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_session *session = conn_ent->ud;
if (!rspamd_controller_check_password (conn_ent, session, msg, TRUE)) {
return 0;
static ucl_object_t *
rspamd_controller_cache_item_to_ucl (struct cache_item *item)
{
- ucl_object_t *obj;
+ ucl_object_t *obj;
obj = ucl_object_typed_new (UCL_OBJECT);
ucl_object_insert_key (obj, ucl_object_fromstring (item->s->symbol),
- "symbol", 0, false);
+ "symbol", 0, false);
ucl_object_insert_key (obj, ucl_object_fromdouble (item->s->weight),
- "weight", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromint (item->s->frequency),
- "frequency", 0, false);
+ "weight", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromint (item->s->frequency),
+ "frequency", 0, false);
ucl_object_insert_key (obj, ucl_object_fromdouble (item->s->avg_time),
- "time", 0, false);
+ "time", 0, false);
return obj;
}
* reply: json array of all counters
*/
static int
-rspamd_controller_handle_counters (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+rspamd_controller_handle_counters (
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- ucl_object_t *top;
- GList *cur;
- struct cache_item *item;
- struct symbols_cache *cache;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ ucl_object_t *top;
+ GList *cur;
+ struct cache_item *item;
+ struct symbols_cache *cache;
if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
return 0;
while (cur) {
item = cur->data;
if (!item->is_callback) {
- ucl_array_append (top, rspamd_controller_cache_item_to_ucl (item));
+ ucl_array_append (top, rspamd_controller_cache_item_to_ucl (
+ item));
}
cur = g_list_next (cur);
}
while (cur) {
item = cur->data;
if (!item->is_callback) {
- ucl_array_append (top, rspamd_controller_cache_item_to_ucl (item));
+ ucl_array_append (top, rspamd_controller_cache_item_to_ucl (
+ item));
}
cur = g_list_next (cur);
}
static int
rspamd_controller_handle_custom (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_controller_session *session = conn_ent->ud;
- struct rspamd_custom_controller_command *cmd;
+ struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_custom_controller_command *cmd;
cmd = g_hash_table_lookup (session->ctx->custom_commands, msg->url->str);
if (cmd == NULL || cmd->handler == NULL) {
return 0;
}
- if (!rspamd_controller_check_password (conn_ent, session, msg, cmd->privilleged)) {
+ if (!rspamd_controller_check_password (conn_ent, session, msg,
+ cmd->privilleged)) {
return 0;
}
if (cmd->require_message && (msg->body == NULL || msg->body->len == 0)) {
msg_err ("got zero length body, cannot continue");
- rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
+ rspamd_controller_send_error (conn_ent,
+ 400,
+ "Empty body is not permitted");
return 0;
}
}
static void
-rspamd_controller_error_handler (struct rspamd_http_connection_entry *conn_ent, GError *err)
+rspamd_controller_error_handler (struct rspamd_http_connection_entry *conn_ent,
+ GError *err)
{
msg_err ("http error occurred: %s", err->message);
}
static void
rspamd_controller_finish_handler (struct rspamd_http_connection_entry *conn_ent)
{
- struct rspamd_controller_session *session = conn_ent->ud;
+ struct rspamd_controller_session *session = conn_ent->ud;
if (session->task != NULL) {
destroy_session (session->task->s);
static void
rspamd_controller_accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *) arg;
- struct rspamd_controller_worker_ctx *ctx;
- struct rspamd_controller_session *nsession;
- rspamd_inet_addr_t addr;
- gint nfd;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_controller_worker_ctx *ctx;
+ struct rspamd_controller_session *nsession;
+ rspamd_inet_addr_t addr;
+ gint nfd;
ctx = worker->ctx;
if ((nfd =
- rspamd_accept_from_socket (fd, &addr)) == -1) {
+ rspamd_accept_from_socket (fd, &addr)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
}
msg_info ("accepted connection from %s port %d",
- rspamd_inet_address_to_string (&addr),
- rspamd_inet_address_get_port (&addr));
+ rspamd_inet_address_to_string (&addr),
+ rspamd_inet_address_get_port (&addr));
nsession = g_slice_alloc0 (sizeof (struct rspamd_controller_session));
nsession->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
gpointer
init_controller_worker (struct rspamd_config *cfg)
{
- struct rspamd_controller_worker_ctx *ctx;
- GQuark type;
+ struct rspamd_controller_worker_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("controller");
ctx->timeout = DEFAULT_WORKER_IO_TIMEOUT;
rspamd_rcl_register_worker_option (cfg, type, "password",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
rspamd_rcl_register_worker_option (cfg, type, "enable_password",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
rspamd_rcl_register_worker_option (cfg, type, "ssl",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, use_ssl), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, use_ssl), 0);
rspamd_rcl_register_worker_option (cfg, type, "ssl_cert",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_cert), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_cert), 0);
rspamd_rcl_register_worker_option (cfg, type, "ssl_key",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_key), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_key), 0);
rspamd_rcl_register_worker_option (cfg, type, "timeout",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx,
+ timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
rspamd_rcl_register_worker_option (cfg, type, "secure_ip",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, secure_ip), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, secure_ip), 0);
rspamd_rcl_register_worker_option (cfg, type, "static_dir",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, static_files_dir), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx,
+ static_files_dir), 0);
return ctx;
}
gpointer key, value;
- ctx->ev_base = rspamd_prepare_worker (worker, "controller", rspamd_controller_accept_socket);
+ ctx->ev_base = rspamd_prepare_worker (worker,
+ "controller",
+ rspamd_controller_accept_socket);
msec_to_tv (ctx->timeout, &ctx->io_tv);
ctx->start_time = time (NULL);
ctx->custom_commands = g_hash_table_new (rspamd_strcase_hash,
rspamd_strcase_equal);
if (ctx->secure_ip != NULL) {
- if (!add_map (worker->srv->cfg, ctx->secure_ip, "Allow webui access from the specified IP",
- read_radix_list, fin_radix_list, (void **)&ctx->secure_map)) {
- if (!rspamd_config_parse_ip_list (ctx->secure_ip, &ctx->secure_map)) {
- msg_warn ("cannot load or parse ip list from '%s'", ctx->secure_ip);
+ if (!add_map (worker->srv->cfg, ctx->secure_ip,
+ "Allow webui access from the specified IP",
+ read_radix_list, fin_radix_list, (void **)&ctx->secure_map)) {
+ if (!rspamd_config_parse_ip_list (ctx->secure_ip,
+ &ctx->secure_map)) {
+ msg_warn ("cannot load or parse ip list from '%s'",
+ ctx->secure_ip);
}
}
}
ctx->static_files_dir);
/* Add callbacks for different methods */
- rspamd_http_router_add_path (ctx->http, PATH_AUTH, rspamd_controller_handle_auth);
- rspamd_http_router_add_path (ctx->http, PATH_SYMBOLS, rspamd_controller_handle_symbols);
- rspamd_http_router_add_path (ctx->http, PATH_ACTIONS, rspamd_controller_handle_actions);
- rspamd_http_router_add_path (ctx->http, PATH_MAPS, rspamd_controller_handle_maps);
- rspamd_http_router_add_path (ctx->http, PATH_GET_MAP, rspamd_controller_handle_get_map);
- rspamd_http_router_add_path (ctx->http, PATH_PIE_CHART, rspamd_controller_handle_pie_chart);
- rspamd_http_router_add_path (ctx->http, PATH_HISTORY, rspamd_controller_handle_history);
- rspamd_http_router_add_path (ctx->http, PATH_LEARN_SPAM, rspamd_controller_handle_learnspam);
- rspamd_http_router_add_path (ctx->http, PATH_LEARN_HAM, rspamd_controller_handle_learnham);
- rspamd_http_router_add_path (ctx->http, PATH_SAVE_ACTIONS, rspamd_controller_handle_saveactions);
- rspamd_http_router_add_path (ctx->http, PATH_SAVE_SYMBOLS, rspamd_controller_handle_savesymbols);
- rspamd_http_router_add_path (ctx->http, PATH_SAVE_MAP, rspamd_controller_handle_savemap);
- rspamd_http_router_add_path (ctx->http, PATH_SCAN, rspamd_controller_handle_scan);
- rspamd_http_router_add_path (ctx->http, PATH_CHECK, rspamd_controller_handle_scan);
- rspamd_http_router_add_path (ctx->http, PATH_STAT, rspamd_controller_handle_stat);
- rspamd_http_router_add_path (ctx->http, PATH_STAT_RESET, rspamd_controller_handle_statreset);
- rspamd_http_router_add_path (ctx->http, PATH_COUNTERS, rspamd_controller_handle_counters);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_AUTH,
+ rspamd_controller_handle_auth);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_SYMBOLS,
+ rspamd_controller_handle_symbols);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_ACTIONS,
+ rspamd_controller_handle_actions);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_MAPS,
+ rspamd_controller_handle_maps);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_GET_MAP,
+ rspamd_controller_handle_get_map);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_PIE_CHART,
+ rspamd_controller_handle_pie_chart);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_HISTORY,
+ rspamd_controller_handle_history);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_LEARN_SPAM,
+ rspamd_controller_handle_learnspam);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_LEARN_HAM,
+ rspamd_controller_handle_learnham);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_SAVE_ACTIONS,
+ rspamd_controller_handle_saveactions);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_SAVE_SYMBOLS,
+ rspamd_controller_handle_savesymbols);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_SAVE_MAP,
+ rspamd_controller_handle_savemap);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_SCAN,
+ rspamd_controller_handle_scan);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_CHECK,
+ rspamd_controller_handle_scan);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_STAT,
+ rspamd_controller_handle_stat);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_STAT_RESET,
+ rspamd_controller_handle_statreset);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_COUNTERS,
+ rspamd_controller_handle_counters);
/* Attach plugins */
cur = g_list_first (ctx->cfg->filters);
f = cur->data;
mctx = g_hash_table_lookup (ctx->cfg->c_modules, f->module->name);
if (mctx != NULL && f->module->module_attach_controller_func != NULL) {
- f->module->module_attach_controller_func (mctx, ctx->custom_commands);
+ f->module->module_attach_controller_func (mctx,
+ ctx->custom_commands);
}
cur = g_list_next (cur);
}
g_hash_table_iter_init (&iter, ctx->custom_commands);
while (g_hash_table_iter_next (&iter, &key, &value)) {
- rspamd_http_router_add_path (ctx->http, key, rspamd_controller_handle_custom);
+ rspamd_http_router_add_path (ctx->http,
+ key,
+ rspamd_controller_handle_custom);
}
#if 0
- rspamd_http_router_add_path (ctx->http, PATH_GRAPH, rspamd_controller_handle_graph, ctx);
+ rspamd_http_router_add_path (ctx->http,
+ PATH_GRAPH,
+ rspamd_controller_handle_graph,
+ ctx);
#endif
- ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
+ ctx->resolver = dns_resolver_init (worker->srv->logger,
+ ctx->ev_base,
+ worker->srv->cfg);
/* Maps events */
start_map_watch (worker->srv->cfg, ctx->ev_base);
* Rspamd fuzzy storage server
*/
+#include "bloom.h"
+#include "cfg_file.h"
#include "config.h"
-#include "util.h"
+#include "fuzzy.h"
+#include "fuzzy_storage.h"
#include "main.h"
+#include "map.h"
+#include "message.h"
#include "protocol.h"
#include "upstream.h"
-#include "cfg_file.h"
#include "url.h"
-#include "message.h"
-#include "fuzzy.h"
-#include "bloom.h"
-#include "map.h"
-#include "fuzzy_storage.h"
+#include "util.h"
/* This number is used as limit while comparing two fuzzy hashes, this value can vary from 0 to 100 */
#define LEV_LIMIT 99
/* Current version of fuzzy hash file format */
#define CURRENT_FUZZY_VERSION 1
-#define INVALID_NODE_TIME (guint64)-1
+#define INVALID_NODE_TIME (guint64) - 1
/* Init functions */
gpointer init_fuzzy (struct rspamd_config *cfg);
void start_fuzzy (struct rspamd_worker *worker);
worker_t fuzzy_worker = {
- "fuzzy", /* Name */
- init_fuzzy, /* Init function */
- start_fuzzy, /* Start function */
- TRUE, /* No socket */
- TRUE, /* Unique */
- TRUE, /* Threaded */
- FALSE, /* Non killable */
- SOCK_DGRAM /* UDP socket */
+ "fuzzy", /* Name */
+ init_fuzzy, /* Init function */
+ start_fuzzy, /* Start function */
+ TRUE, /* No socket */
+ TRUE, /* Unique */
+ TRUE, /* Threaded */
+ FALSE, /* Non killable */
+ SOCK_DGRAM /* UDP socket */
};
-static GQueue *hashes[BUCKETS];
-static GQueue *frequent;
-static GHashTable *static_hash;
-static rspamd_bloom_filter_t *bf;
+static GQueue *hashes[BUCKETS];
+static GQueue *frequent;
+static GHashTable *static_hash;
+static rspamd_bloom_filter_t *bf;
/* Number of cache modifications */
-static guint32 mods = 0;
+static guint32 mods = 0;
/* For evtimer */
-static struct timeval tmv;
-static struct event tev;
-static struct rspamd_stat *server_stat;
+static struct timeval tmv;
+static struct event tev;
+static struct rspamd_stat *server_stat;
struct rspamd_fuzzy_storage_ctx {
- gboolean strict_hash;
- char *hashfile;
- gdouble expire;
- guint32 frequent_score;
- guint32 max_mods;
- radix_tree_t *update_ips;
- gchar *update_map;
- struct event_base *ev_base;
- rspamd_rwlock_t *tree_lock;
- rspamd_mutex_t *update_mtx;
- GCond *update_cond;
- GThread *update_thread;
+ gboolean strict_hash;
+ char *hashfile;
+ gdouble expire;
+ guint32 frequent_score;
+ guint32 max_mods;
+ radix_tree_t *update_ips;
+ gchar *update_map;
+ struct event_base *ev_base;
+ rspamd_rwlock_t *tree_lock;
+ rspamd_mutex_t *update_mtx;
+ GCond *update_cond;
+ GThread *update_thread;
};
struct rspamd_fuzzy_node {
- gint32 value;
- gint32 flag;
- guint64 time;
- fuzzy_hash_t h;
+ gint32 value;
+ gint32 flag;
+ guint64 time;
+ fuzzy_hash_t h;
};
struct fuzzy_session {
*/
static void
expire_nodes (gpointer *to_expire, gint expired_num,
- struct rspamd_fuzzy_storage_ctx *ctx)
+ struct rspamd_fuzzy_storage_ctx *ctx)
{
- gint i;
- struct rspamd_fuzzy_node *node;
- GList *cur;
- GQueue *head;
+ gint i;
+ struct rspamd_fuzzy_node *node;
+ GList *cur;
+ GQueue *head;
- for (i = 0; i < expired_num; i ++) {
+ for (i = 0; i < expired_num; i++) {
if (ctx->strict_hash) {
node = (struct rspamd_fuzzy_node *)to_expire[i];
if (node->time != INVALID_NODE_TIME) {
- server_stat->fuzzy_hashes_expired ++;
+ server_stat->fuzzy_hashes_expired++;
}
- server_stat->fuzzy_hashes --;
+ server_stat->fuzzy_hashes--;
rspamd_bloom_del (bf, node->h.hash_pipe);
g_hash_table_remove (static_hash, node->h.hash_pipe);
}
g_queue_delete_link (head, cur);
rspamd_bloom_del (bf, node->h.hash_pipe);
if (node->time != INVALID_NODE_TIME) {
- server_stat->fuzzy_hashes_expired ++;
+ server_stat->fuzzy_hashes_expired++;
}
server_stat->fuzzy_hashes--;
g_slice_free1 (sizeof(struct rspamd_fuzzy_node), node);
static gpointer
sync_cache (gpointer ud)
{
- static const int max_expired = 8192;
- struct rspamd_worker *wrk = ud;
- gint fd, i, expired_num = 0;
- gchar *filename, header[4];
- GList *cur;
- struct rspamd_fuzzy_node *node;
- gpointer *nodes_expired = NULL;
- guint64 expire, now;
+ static const int max_expired = 8192;
+ struct rspamd_worker *wrk = ud;
+ gint fd, i, expired_num = 0;
+ gchar *filename, header[4];
+ GList *cur;
+ struct rspamd_fuzzy_node *node;
+ gpointer *nodes_expired = NULL;
+ guint64 expire, now;
struct rspamd_fuzzy_storage_ctx *ctx;
- GHashTableIter iter;
+ GHashTableIter iter;
ctx = wrk->ctx;
- for (;;) {
+ for (;; ) {
rspamd_mutex_lock (ctx->update_mtx);
expire = ctx->expire;
if ((fd = open (filename, O_WRONLY | O_TRUNC | O_CREAT,
- S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH)) == -1) {
- msg_err(
- "cannot create hash file %s: %s", filename, strerror (errno));
+ S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH)) == -1) {
+ msg_err (
+ "cannot create hash file %s: %s", filename, strerror (errno));
rspamd_mutex_unlock (ctx->update_mtx);
if (wanna_die) {
return NULL;
memcpy (header, FUZZY_FILE_MAGIC, 3);
header[3] = (gchar) CURRENT_FUZZY_VERSION;
if (write (fd, header, sizeof(header)) == -1) {
- msg_err(
- "cannot write file %s while writing header: %s", filename, strerror (errno));
+ msg_err (
+ "cannot write file %s while writing header: %s",
+ filename,
+ strerror (errno));
goto end;
}
g_hash_table_iter_init (&iter, static_hash);
while (g_hash_table_iter_next (&iter, NULL, (void **)&node)) {
- if (node->time == INVALID_NODE_TIME || now - node->time > expire) {
+ if (node->time == INVALID_NODE_TIME || now - node->time >
+ expire) {
if (nodes_expired == NULL) {
- nodes_expired = g_malloc (max_expired * sizeof (gpointer));
+ nodes_expired = g_malloc (
+ max_expired * sizeof (gpointer));
}
if (expired_num < max_expired) {
- nodes_expired[expired_num ++] = node;
+ nodes_expired[expired_num++] = node;
}
continue;
}
if (write (fd, node, sizeof (struct rspamd_fuzzy_node)) == -1) {
- msg_err ("cannot write file %s: %s", filename, strerror (errno));
+ msg_err ("cannot write file %s: %s", filename,
+ strerror (errno));
goto end;
}
}
while (cur) {
node = cur->data;
if (write (fd, node, sizeof(struct rspamd_fuzzy_node)) == -1) {
- msg_err("cannot write file %s: %s", filename, strerror (errno));
+ msg_err ("cannot write file %s: %s", filename,
+ strerror (errno));
}
cur = g_list_next (cur);
}
node = cur->data;
if (now - node->time > expire) {
if (nodes_expired == NULL) {
- nodes_expired = g_malloc (max_expired * sizeof (gpointer));
+ nodes_expired =
+ g_malloc (max_expired * sizeof (gpointer));
}
if (expired_num < max_expired) {
- nodes_expired[expired_num ++] = cur;
+ nodes_expired[expired_num++] = cur;
}
cur = g_list_next (cur);
continue;
}
- if (write (fd, node, sizeof(struct rspamd_fuzzy_node)) == -1) {
- msg_err(
- "cannot write file %s: %s", filename, strerror (errno));
+ if (write (fd, node,
+ sizeof(struct rspamd_fuzzy_node)) == -1) {
+ msg_err (
+ "cannot write file %s: %s", filename,
+ strerror (errno));
goto end;
}
cur = g_list_next (cur);
static void
sigterm_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
struct rspamd_fuzzy_storage_ctx *ctx;
- static struct timeval tv = {
+ static struct timeval tv = {
.tv_sec = 0,
.tv_usec = 0
};
static void
sigusr2_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
- struct timeval tv;
+ struct timeval tv;
struct rspamd_fuzzy_storage_ctx *ctx;
ctx = worker->ctx;
return;
}
-static gboolean
+static gboolean
read_hashes_file (struct rspamd_worker *wrk)
{
- gint r, fd, i, version = 0;
- struct stat st;
- gchar *filename, header[4];
- gboolean touch_stat = TRUE;
- struct rspamd_fuzzy_node *node;
+ gint r, fd, i, version = 0;
+ struct stat st;
+ gchar *filename, header[4];
+ gboolean touch_stat = TRUE;
+ struct rspamd_fuzzy_node *node;
struct rspamd_fuzzy_storage_ctx *ctx = wrk->ctx;
struct {
- gint32 value;
- guint64 time;
- fuzzy_hash_t h;
- } legacy_node;
+ gint32 value;
+ guint64 time;
+ fuzzy_hash_t h;
+ } legacy_node;
if (server_stat->fuzzy_hashes != 0) {
touch_stat = FALSE;
close (fd);
return FALSE;
}
- msg_info ("reading fuzzy hashes storage file of version %d of size %d",
- version, (gint)(st.st_size - sizeof (header)) / sizeof (struct rspamd_fuzzy_node));
+ msg_info (
+ "reading fuzzy hashes storage file of version %d of size %d",
+ version,
+ (gint)(st.st_size -
+ sizeof (header)) / sizeof (struct rspamd_fuzzy_node));
}
else {
/* Old version */
version = 0;
- msg_info ("got old version of fuzzy hashes storage, it would be converted to new version %d automatically",
- CURRENT_FUZZY_VERSION);
+ msg_info (
+ "got old version of fuzzy hashes storage, it would be converted to new version %d automatically",
+ CURRENT_FUZZY_VERSION);
/* Rewind file */
(void)lseek (fd, 0, SEEK_SET);
}
}
- for (;;) {
+ for (;; ) {
node = g_slice_alloc (sizeof (struct rspamd_fuzzy_node));
if (version == 0) {
r = read (fd, &legacy_node, sizeof (legacy_node));
}
rspamd_bloom_add (bf, node->h.hash_pipe);
if (touch_stat) {
- server_stat->fuzzy_hashes ++;
+ server_stat->fuzzy_hashes++;
}
}
if (!ctx->strict_hash) {
/* Sort everything */
g_queue_sort (frequent, compare_nodes, NULL);
- for (i = 0; i < BUCKETS; i ++) {
+ for (i = 0; i < BUCKETS; i++) {
g_queue_sort (hashes[i], compare_nodes, NULL);
}
}
close (fd);
if (r > 0) {
- msg_warn ("ignore garbage at the end of file, length of garbage: %d", r);
+ msg_warn ("ignore garbage at the end of file, length of garbage: %d",
+ r);
}
else if (r == -1) {
msg_err ("cannot open read file %s: %s", filename, strerror (errno));
static inline struct rspamd_fuzzy_node *
check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value,
- guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
+ guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
{
- GList *cur;
- struct rspamd_fuzzy_node *h;
- gint prob = 0;
+ GList *cur;
+ struct rspamd_fuzzy_node *h;
+ gint prob = 0;
if (ctx->strict_hash) {
h = g_hash_table_lookup (static_hash, s->hash_pipe);
}
else if (update_value == 0 && time - h->time > ctx->expire) {
h->time = INVALID_NODE_TIME;
- server_stat->fuzzy_hashes_expired ++;
+ server_stat->fuzzy_hashes_expired++;
return NULL;
}
else if (h->h.block_size== s->block_size) {
}
else if (time - h->time > ctx->expire) {
h->time = INVALID_NODE_TIME;
- server_stat->fuzzy_hashes_expired ++;
+ server_stat->fuzzy_hashes_expired++;
return NULL;
}
return h;
}
else if (time - h->time > ctx->expire) {
h->time = INVALID_NODE_TIME;
- server_stat->fuzzy_hashes_expired ++;
+ server_stat->fuzzy_hashes_expired++;
return NULL;
}
if (h->value > (gint)ctx->frequent_score) {
return NULL;
}
-static gint
-process_check_command (struct fuzzy_cmd *cmd, gint *flag, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
+static gint
+process_check_command (struct fuzzy_cmd *cmd,
+ gint *flag,
+ guint64 time,
+ struct rspamd_fuzzy_storage_ctx *ctx)
{
- fuzzy_hash_t s;
- struct rspamd_fuzzy_node *h;
+ fuzzy_hash_t s;
+ struct rspamd_fuzzy_node *h;
if (!rspamd_bloom_check (bf, cmd->hash)) {
h = check_hash_node (NULL, &s, 0, time, ctx);
}
else {
- h = check_hash_node (hashes[cmd->blocksize % BUCKETS], &s, 0, time, ctx);
+ h =
+ check_hash_node (hashes[cmd->blocksize % BUCKETS], &s, 0, time,
+ ctx);
}
rspamd_rwlock_reader_unlock (ctx->tree_lock);
}
}
-static gboolean
-update_hash (struct fuzzy_cmd *cmd, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
+static gboolean
+update_hash (struct fuzzy_cmd *cmd,
+ guint64 time,
+ struct rspamd_fuzzy_storage_ctx *ctx)
{
- fuzzy_hash_t s;
- struct rspamd_fuzzy_node *n;
+ fuzzy_hash_t s;
+ struct rspamd_fuzzy_node *n;
memcpy (s.hash_pipe, cmd->hash, sizeof (s.hash_pipe));
s.block_size = cmd->blocksize;
- mods ++;
+ mods++;
rspamd_rwlock_writer_lock (ctx->tree_lock);
if (ctx->strict_hash) {
n = check_hash_node (NULL, &s, cmd->value, time, ctx);
}
else {
- n = check_hash_node (hashes[cmd->blocksize % BUCKETS], &s, cmd->value, time, ctx);
+ n = check_hash_node (hashes[cmd->blocksize % BUCKETS],
+ &s,
+ cmd->value,
+ time,
+ ctx);
}
rspamd_rwlock_writer_unlock (ctx->tree_lock);
return FALSE;
}
-static gboolean
-process_write_command (struct fuzzy_cmd *cmd, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
+static gboolean
+process_write_command (struct fuzzy_cmd *cmd,
+ guint64 time,
+ struct rspamd_fuzzy_storage_ctx *ctx)
{
- struct rspamd_fuzzy_node *h;
+ struct rspamd_fuzzy_node *h;
if (rspamd_bloom_check (bf, cmd->hash)) {
if (update_hash (cmd, time, ctx)) {
rspamd_rwlock_writer_unlock (ctx->tree_lock);
mods++;
- server_stat->fuzzy_hashes ++;
+ server_stat->fuzzy_hashes++;
msg_info ("fuzzy hash was successfully added");
return TRUE;
}
static gboolean
-delete_hash (GQueue *hash, fuzzy_hash_t *s, struct rspamd_fuzzy_storage_ctx *ctx)
+delete_hash (GQueue *hash, fuzzy_hash_t *s,
+ struct rspamd_fuzzy_storage_ctx *ctx)
{
- GList *cur, *tmp;
- struct rspamd_fuzzy_node *h;
- gboolean res = FALSE;
+ GList *cur, *tmp;
+ struct rspamd_fuzzy_node *h;
+ gboolean res = FALSE;
if (ctx->strict_hash) {
rspamd_rwlock_writer_lock (ctx->tree_lock);
if (g_hash_table_remove (static_hash, s->hash_pipe)) {
rspamd_bloom_del (bf, s->hash_pipe);
msg_info ("fuzzy hash was successfully deleted");
- server_stat->fuzzy_hashes --;
+ server_stat->fuzzy_hashes--;
mods++;
}
rspamd_rwlock_writer_unlock (ctx->tree_lock);
g_queue_delete_link (hash, tmp);
rspamd_bloom_del (bf, s->hash_pipe);
msg_info ("fuzzy hash was successfully deleted");
- server_stat->fuzzy_hashes --;
+ server_stat->fuzzy_hashes--;
mods++;
res = TRUE;
continue;
}
-static gboolean
-process_delete_command (struct fuzzy_cmd *cmd, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
+static gboolean
+process_delete_command (struct fuzzy_cmd *cmd,
+ guint64 time,
+ struct rspamd_fuzzy_storage_ctx *ctx)
{
- fuzzy_hash_t s;
- gboolean res = FALSE;
+ fuzzy_hash_t s;
+ gboolean res = FALSE;
if (!rspamd_bloom_check (bf, cmd->hash)) {
return FALSE;
return FALSE;
}
if (radix32tree_find (session->ctx->update_ips,
- ntohl (session->client_addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
+ ntohl (session->client_addr.s4.sin_addr.s_addr)) ==
+ RADIX_NO_VALUE) {
return FALSE;
}
}
return TRUE;
}
-#define CMD_PROCESS(x) \
-do { \
-if (process_##x##_command (&session->cmd, session->time, session->worker->ctx)) { \
- if (sendto (session->fd, "OK" CRLF, sizeof ("OK" CRLF) - 1, 0, &session->client_addr.ss, session->salen) == -1) { \
- msg_err ("error while writing reply: %s", strerror (errno)); \
- } \
-} \
-else { \
- if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0, &session->client_addr.ss, session->salen) == -1) { \
- msg_err ("error while writing reply: %s", strerror (errno)); \
- } \
-} \
-} while(0)
+#define CMD_PROCESS(x) \
+ do { \
+ if (process_ ## x ## _command (&session->cmd, session->time, \
+ session->worker->ctx)) { \
+ if (sendto (session->fd, "OK" CRLF, sizeof ("OK" CRLF) - 1, 0, \
+ &session->client_addr.ss, session->salen) == -1) { \
+ msg_err ("error while writing reply: %s", strerror (errno)); \
+ } \
+ } \
+ else { \
+ if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0, \
+ &session->client_addr.ss, session->salen) == -1) { \
+ msg_err ("error while writing reply: %s", strerror (errno)); \
+ } \
+ } \
+ } while (0)
static void
process_fuzzy_command (struct fuzzy_session *session)
{
- gint r, flag = 0;
- gchar buf[64];
+ gint r, flag = 0;
+ gchar buf[64];
switch (session->cmd.cmd) {
case FUZZY_CHECK:
- r = process_check_command (&session->cmd, &flag, session->time, session->worker->ctx);
+ r = process_check_command (&session->cmd,
+ &flag,
+ session->time,
+ session->worker->ctx);
if (r != 0) {
r = rspamd_snprintf (buf, sizeof (buf), "OK %d %d" CRLF, r, flag);
if (sendto (session->fd, buf, r, 0,
- &session->client_addr.ss, session->salen) == -1) {
+ &session->client_addr.ss, session->salen) == -1) {
msg_err ("error while writing reply: %s", strerror (errno));
}
}
else {
if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0,
- &session->client_addr.ss, session->salen) == -1) {
+ &session->client_addr.ss, session->salen) == -1) {
msg_err ("error while writing reply: %s", strerror (errno));
}
}
case FUZZY_WRITE:
if (!check_fuzzy_client (session)) {
msg_info ("try to insert a hash from an untrusted address");
- if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1, 0,
- &session->client_addr.ss, session->salen) == -1) {
+ if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1,
+ 0,
+ &session->client_addr.ss, session->salen) == -1) {
msg_err ("error while writing reply: %s", strerror (errno));
}
}
case FUZZY_DEL:
if (!check_fuzzy_client (session)) {
msg_info ("try to delete a hash from an untrusted address");
- if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1, 0,
- &session->client_addr.ss, session->salen) == -1) {
+ if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1,
+ 0,
+ &session->client_addr.ss, session->salen) == -1) {
msg_err ("error while writing reply: %s", strerror (errno));
}
}
break;
default:
if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0,
- &session->client_addr.ss, session->salen) == -1) {
+ &session->client_addr.ss, session->salen) == -1) {
msg_err ("error while writing reply: %s", strerror (errno));
}
break;
static void
accept_fuzzy_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- struct fuzzy_session session;
- ssize_t r;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ struct fuzzy_session session;
+ ssize_t r;
struct {
- u_char cmd;
- guint32 blocksize;
- gint32 value;
- u_char hash[FUZZY_HASHLEN];
- } legacy_cmd;
+ u_char cmd;
+ guint32 blocksize;
+ gint32 value;
+ u_char hash[FUZZY_HASHLEN];
+ } legacy_cmd;
session.worker = worker;
session.fd = fd;
- session.pos = (u_char *) & session.cmd;
+ session.pos = (u_char *) &session.cmd;
session.salen = sizeof (session.client_addr);
session.ctx = worker->ctx;
session.time = (guint64)time (NULL);
/* Got some data */
if (what == EV_READ) {
while ((r = recvfrom (fd, session.pos, sizeof (struct fuzzy_cmd),
- MSG_WAITALL, &session.client_addr.ss, &session.salen)) == -1) {
+ MSG_WAITALL, &session.client_addr.ss, &session.salen)) == -1) {
if (errno == EINTR) {
continue;
}
- msg_err ("got error while reading from socket: %d, %s", errno, strerror (errno));
+ msg_err ("got error while reading from socket: %d, %s",
+ errno,
+ strerror (errno));
return;
}
if (r == sizeof (struct fuzzy_cmd)) {
session.cmd.blocksize = legacy_cmd.blocksize;
session.cmd.value = legacy_cmd.value;
session.cmd.flag = 0;
- memcpy (session.cmd.hash, legacy_cmd.hash, sizeof (legacy_cmd.hash));
+ memcpy (session.cmd.hash, legacy_cmd.hash,
+ sizeof (legacy_cmd.hash));
process_fuzzy_command (&session);
}
else {
- msg_err ("got incomplete data while reading from socket: %d, %s", errno, strerror (errno));
+ msg_err ("got incomplete data while reading from socket: %d, %s",
+ errno,
+ strerror (errno));
return;
}
}
static void
sync_callback (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- struct rspamd_fuzzy_storage_ctx *ctx;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ struct rspamd_fuzzy_storage_ctx *ctx;
ctx = worker->ctx;
/* Timer event */
gpointer
init_fuzzy (struct rspamd_config *cfg)
{
- struct rspamd_fuzzy_storage_ctx *ctx;
- GQuark type;
+ struct rspamd_fuzzy_storage_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("fuzzy");
#endif
rspamd_rcl_register_worker_option (cfg, type, "hashfile",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, hashfile), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, hashfile), 0);
rspamd_rcl_register_worker_option (cfg, type, "max_mods",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, max_mods), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx,
+ max_mods), RSPAMD_CL_FLAG_INT_32);
rspamd_rcl_register_worker_option (cfg, type, "frequent_score",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, frequent_score), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx,
+ frequent_score), RSPAMD_CL_FLAG_INT_32);
rspamd_rcl_register_worker_option (cfg, type, "expire",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, expire), RSPAMD_CL_FLAG_TIME_FLOAT);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx,
+ expire), RSPAMD_CL_FLAG_TIME_FLOAT);
rspamd_rcl_register_worker_option (cfg, type, "strict_hash",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, strict_hash), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, strict_hash), 0);
rspamd_rcl_register_worker_option (cfg, type, "allow_update",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, update_map), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, update_map), 0);
return ctx;
void
start_fuzzy (struct rspamd_worker *worker)
{
- struct event sev;
+ struct event sev;
struct rspamd_fuzzy_storage_ctx *ctx = worker->ctx;
- GError *err = NULL;
+ GError *err = NULL;
gint i;
- ctx->ev_base = rspamd_prepare_worker (worker, "controller", accept_fuzzy_socket);
+ ctx->ev_base = rspamd_prepare_worker (worker,
+ "controller",
+ accept_fuzzy_socket);
server_stat = worker->srv->stat;
/* Custom SIGUSR2 handler */
event_del (&worker->sig_ev_usr2);
- signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler, (void *) worker);
+ signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler,
+ (void *) worker);
event_base_set (ctx->ev_base, &worker->sig_ev_usr2);
signal_add (&worker->sig_ev_usr2, NULL);
bf = rspamd_bloom_create (2000000L, RSPAMD_DEFAULT_BLOOM_HASHES);
/* Try to read hashes from file */
if (!read_hashes_file (worker)) {
- msg_err ("cannot read hashes file, it can be created after save procedure");
+ msg_err (
+ "cannot read hashes file, it can be created after save procedure");
}
/* Timer event */
/* Create radix tree */
if (ctx->update_map != NULL) {
- if (!add_map (worker->srv->cfg, ctx->update_map, "Allow fuzzy updates from specified addresses",
- read_radix_list, fin_radix_list, (void **)&ctx->update_ips)) {
- if (!rspamd_config_parse_ip_list (ctx->update_map, &ctx->update_ips)) {
- msg_warn ("cannot load or parse ip list from '%s'", ctx->update_map);
+ if (!add_map (worker->srv->cfg, ctx->update_map,
+ "Allow fuzzy updates from specified addresses",
+ read_radix_list, fin_radix_list, (void **)&ctx->update_ips)) {
+ if (!rspamd_config_parse_ip_list (ctx->update_map,
+ &ctx->update_ips)) {
+ msg_warn ("cannot load or parse ip list from '%s'",
+ ctx->update_map);
}
}
}
/* Maps events */
start_map_watch (worker->srv->cfg, ctx->ev_base);
- ctx->update_thread = rspamd_create_thread ("fuzzy update", sync_cache, worker, &err);
+ ctx->update_thread = rspamd_create_thread ("fuzzy update",
+ sync_cache,
+ worker,
+ &err);
if (ctx->update_thread == NULL) {
msg_err ("error creating update thread: %s", err->message);
}
#define RSPAMD_FUZZY_STORAGE_H
#include "config.h"
-#include "main.h"
#include "fuzzy.h"
+#include "main.h"
/* Commands for fuzzy storage */
#define FUZZY_CHECK 0
/** Create new kv storage */
struct rspamd_kv_storage *
-rspamd_kv_storage_new (gint id, const gchar *name, struct rspamd_kv_cache *cache, struct rspamd_kv_backend *backend, struct rspamd_kv_expire *expire,
- gsize max_elts, gsize max_memory, gboolean no_overwrite)
+rspamd_kv_storage_new (gint id,
+ const gchar *name,
+ struct rspamd_kv_cache *cache,
+ struct rspamd_kv_backend *backend,
+ struct rspamd_kv_expire *expire,
+ gsize max_elts,
+ gsize max_memory,
+ gboolean no_overwrite)
{
- struct rspamd_kv_storage *new;
+ struct rspamd_kv_storage *new;
new = g_slice_alloc (sizeof (struct rspamd_kv_storage));
new->elts = 0;
/** Internal insertion to the kv storage from backend */
gboolean
-rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
- gpointer data, gsize len, gint flags, guint expire, struct rspamd_kv_element **pelt)
+rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ gpointer data,
+ gsize len,
+ gint flags,
+ guint expire,
+ struct rspamd_kv_element **pelt)
{
- gint steps = 0;
- struct rspamd_kv_element *elt;
+ gint steps = 0;
+ struct rspamd_kv_element *elt;
RW_W_LOCK (&storage->rwlock);
/* Hard limit */
if (storage->max_memory > 0) {
if (len > storage->max_memory) {
- msg_info ("<%s>: trying to insert value of length %z while limit is %z", storage->name,
- len, storage->max_memory);
+ msg_info (
+ "<%s>: trying to insert value of length %z while limit is %z",
+ storage->name,
+ len,
+ storage->max_memory);
RW_W_UNLOCK (&storage->rwlock);
return FALSE;
}
/* Now check limits */
while (storage->memory + len > storage->max_memory) {
if (storage->expire) {
- storage->expire->step_func (storage->expire, storage, time (NULL), steps);
+ storage->expire->step_func (storage->expire, storage, time (
+ NULL), steps);
}
else {
- msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
+ msg_warn (
+ "<%s>: storage is full and no expire function is defined",
+ storage->name);
}
if (++steps > MAX_EXPIRE_STEPS) {
RW_W_UNLOCK (&storage->rwlock);
- msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
+ msg_warn ("<%s>: cannot expire enough keys in storage",
+ storage->name);
return FALSE;
}
}
storage->expire->insert_func (storage->expire, elt);
}
- storage->elts ++;
+ storage->elts++;
storage->memory += ELT_SIZE (elt);
RW_W_UNLOCK (&storage->rwlock);
/** Insert new element to the kv storage */
gboolean
-rspamd_kv_storage_insert (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
- gpointer data, gsize len, gint flags, guint expire)
+rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ gpointer data,
+ gsize len,
+ gint flags,
+ guint expire)
{
- gint steps = 0;
- struct rspamd_kv_element *elt;
- gboolean res = TRUE;
- glong longval;
+ gint steps = 0;
+ struct rspamd_kv_element *elt;
+ gboolean res = TRUE;
+ glong longval;
/* Hard limit */
RW_W_LOCK (&storage->rwlock);
if (storage->max_memory > 0) {
- if (len + sizeof (struct rspamd_kv_element) + keylen >= storage->max_memory) {
- msg_warn ("<%s>: trying to insert value of length %z while limit is %z", storage->name,
- len, storage->max_memory);
+ if (len + sizeof (struct rspamd_kv_element) + keylen >=
+ storage->max_memory) {
+ msg_warn (
+ "<%s>: trying to insert value of length %z while limit is %z",
+ storage->name,
+ len,
+ storage->max_memory);
RW_W_UNLOCK (&storage->rwlock);
return FALSE;
}
/* Now check limits */
while (storage->memory + len + keylen > storage->max_memory) {
if (storage->expire) {
- storage->expire->step_func (storage->expire, storage, time (NULL), steps);
+ storage->expire->step_func (storage->expire, storage, time (
+ NULL), steps);
}
else {
- msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
+ msg_warn (
+ "<%s>: storage is full and no expire function is defined",
+ storage->name);
}
if (++steps > MAX_EXPIRE_STEPS) {
RW_W_UNLOCK (&storage->rwlock);
- msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
+ msg_warn ("<%s>: cannot expire enough keys in storage",
+ storage->name);
return FALSE;
}
}
steps = 0;
while (storage->elts > storage->max_elts) {
if (storage->expire) {
- storage->expire->step_func (storage->expire, storage, time (NULL), steps);
+ storage->expire->step_func (storage->expire, storage, time (
+ NULL), steps);
}
else {
- msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
+ msg_warn (
+ "<%s>: storage is full and no expire function is defined",
+ storage->name);
}
if (++steps > MAX_EXPIRE_STEPS) {
RW_W_UNLOCK (&storage->rwlock);
- msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
+ msg_warn ("<%s>: cannot expire enough keys in storage",
+ storage->name);
return FALSE;
}
}
else {
/* Just do incref and nothing more */
if (storage->backend && storage->backend->incref_func) {
- if (storage->backend->incref_func (storage->backend, key, keylen)) {
+ if (storage->backend->incref_func (storage->backend, key,
+ keylen)) {
RW_W_UNLOCK (&storage->rwlock);
return TRUE;
}
/* First of all check element for integer */
if (rspamd_strtol (data, len, &longval)) {
- elt = storage->cache->insert_func (storage->cache, key, keylen, &longval, sizeof (glong));
+ elt = storage->cache->insert_func (storage->cache,
+ key,
+ keylen,
+ &longval,
+ sizeof (glong));
if (elt == NULL) {
return FALSE;
}
}
}
else {
- elt = storage->cache->insert_func (storage->cache, key, keylen, data, len);
+ elt = storage->cache->insert_func (storage->cache,
+ key,
+ keylen,
+ data,
+ len);
if (elt == NULL) {
RW_W_UNLOCK (&storage->rwlock);
return FALSE;
/* Place to the backend */
if (storage->backend) {
- res = storage->backend->insert_func (storage->backend, key, keylen, elt);
+ res =
+ storage->backend->insert_func (storage->backend, key, keylen, elt);
}
/* Insert to the expire */
storage->expire->insert_func (storage->expire, elt);
}
- storage->elts ++;
+ storage->elts++;
storage->memory += ELT_SIZE (elt);
RW_W_UNLOCK (&storage->rwlock);
/** Replace an element in the kv storage */
gboolean
-rspamd_kv_storage_replace (struct rspamd_kv_storage *storage, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- gboolean res = TRUE;
- gint steps = 0;
+ gboolean res = TRUE;
+ gint steps = 0;
/* Hard limit */
if (storage->max_memory > 0) {
if (elt->size > storage->max_memory) {
- msg_info ("<%s>: trying to replace value of length %z while limit is %z", storage->name,
- elt->size, storage->max_memory);
+ msg_info (
+ "<%s>: trying to replace value of length %z while limit is %z",
+ storage->name,
+ elt->size,
+ storage->max_memory);
return FALSE;
}
while (storage->memory + ELT_SIZE (elt) > storage->max_memory) {
if (storage->expire) {
RW_W_LOCK (&storage->rwlock);
- storage->expire->step_func (storage->expire, storage, time (NULL), steps);
+ storage->expire->step_func (storage->expire, storage, time (
+ NULL), steps);
RW_W_UNLOCK (&storage->rwlock);
}
else {
- msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
+ msg_warn (
+ "<%s>: storage is full and no expire function is defined",
+ storage->name);
}
if (++steps > MAX_EXPIRE_STEPS) {
- msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
+ msg_warn ("<%s>: cannot expire enough keys in storage",
+ storage->name);
return FALSE;
}
}
/* Place to the backend */
if (res && storage->backend) {
- res = storage->backend->replace_func (storage->backend, key, keylen, elt);
+ res =
+ storage->backend->replace_func (storage->backend, key, keylen, elt);
}
RW_W_UNLOCK (&storage->rwlock);
/** Increment value in kvstorage */
gboolean
-rspamd_kv_storage_increment (struct rspamd_kv_storage *storage, gpointer key, guint keylen, glong *value)
+rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ glong *value)
{
- struct rspamd_kv_element *elt = NULL, *belt;
- glong *lp;
+ struct rspamd_kv_element *elt = NULL, *belt;
+ glong *lp;
/* First try to look at cache */
RW_W_LOCK (&storage->rwlock);
/* Put this element into cache */
if ((belt->flags & KV_ELT_INTEGER) != 0) {
RW_W_UNLOCK (&storage->rwlock);
- rspamd_kv_storage_insert_cache (storage, ELT_KEY (belt), keylen, ELT_DATA (belt),
+ rspamd_kv_storage_insert_cache (storage, ELT_KEY (
+ belt), keylen, ELT_DATA (belt),
belt->size, belt->flags,
belt->expire, &elt);
RW_W_LOCK (&storage->rwlock);
}
elt->age = time (NULL);
if (storage->backend) {
- if (storage->backend->replace_func (storage->backend, key, keylen, elt)) {
+ if (storage->backend->replace_func (storage->backend, key, keylen,
+ elt)) {
RW_W_UNLOCK (&storage->rwlock);
return TRUE;
}
}
/** Lookup an element inside kv storage */
-struct rspamd_kv_element*
-rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage, gpointer key, guint keylen, time_t now)
+struct rspamd_kv_element *
+rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ time_t now)
{
- struct rspamd_kv_element *elt = NULL, *belt;
+ struct rspamd_kv_element *elt = NULL, *belt;
/* First try to look at cache */
RW_R_LOCK (&storage->rwlock);
/** Expire an element from kv storage */
struct rspamd_kv_element *
-rspamd_kv_storage_delete (struct rspamd_kv_storage *storage, gpointer key, guint keylen)
+rspamd_kv_storage_delete (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen)
{
- struct rspamd_kv_element *elt;
+ struct rspamd_kv_element *elt;
/* First delete key from cache */
RW_W_LOCK (&storage->rwlock);
if (storage->expire) {
storage->expire->delete_func (storage->expire, elt);
}
- storage->elts --;
+ storage->elts--;
storage->memory -= elt->size;
if ((elt->flags & KV_ELT_DIRTY) != 0) {
elt->flags |= KV_ELT_NEED_FREE;
/** Insert array */
gboolean
-rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
- guint elt_size, gpointer data, gsize len, gint flags, guint expire)
+rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ guint elt_size,
+ gpointer data,
+ gsize len,
+ gint flags,
+ guint expire)
{
- struct rspamd_kv_element *elt;
- guint *es;
- gpointer arr_data;
+ struct rspamd_kv_element *elt;
+ guint *es;
+ gpointer arr_data;
/* Make temporary copy */
arr_data = g_slice_alloc (len + sizeof (guint));
es = arr_data;
*es = elt_size;
memcpy (arr_data, (gchar *)data + sizeof (guint), len);
- if (!rspamd_kv_storage_insert_cache (storage, key, keylen, arr_data, len + sizeof (guint),
- flags, expire, &elt)) {
+ if (!rspamd_kv_storage_insert_cache (storage, key, keylen, arr_data, len +
+ sizeof (guint),
+ flags, expire, &elt)) {
g_slice_free1 (len + sizeof (guint), arr_data);
return FALSE;
}
/* Place to the backend */
if (storage->backend) {
- return storage->backend->insert_func (storage->backend, key, keylen, elt);
+ return storage->backend->insert_func (storage->backend, key, keylen,
+ elt);
}
return TRUE;
/** Set element inside array */
gboolean
-rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
- guint elt_num, gpointer data, gsize len, time_t now)
+rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ guint elt_num,
+ gpointer data,
+ gsize len,
+ time_t now)
{
- struct rspamd_kv_element *elt;
- guint *es;
- gpointer target;
+ struct rspamd_kv_element *elt;
+ guint *es;
+ gpointer target;
elt = rspamd_kv_storage_lookup (storage, key, keylen, now);
if (elt == NULL) {
memcpy (target, data, len);
/* Place to the backend */
if (storage->backend) {
- return storage->backend->replace_func (storage->backend, key, keylen, elt);
+ return storage->backend->replace_func (storage->backend,
+ key,
+ keylen,
+ elt);
}
return TRUE;
/** Get element inside array */
gboolean
-rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
- guint elt_num, gpointer *data, gsize *len, time_t now)
+rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ guint elt_num,
+ gpointer *data,
+ gsize *len,
+ time_t now)
{
- struct rspamd_kv_element *elt;
- guint *es;
- gpointer target;
+ struct rspamd_kv_element *elt;
+ guint *es;
+ gpointer target;
elt = rspamd_kv_storage_lookup (storage, key, keylen, now);
if (elt == NULL) {
*/
struct rspamd_kv_lru_expire {
- expire_init init_func; /*< this callback is called on kv storage initialization */
- expire_insert insert_func; /*< this callback is called when element is inserted */
- expire_step step_func; /*< this callback is used when cache is full */
- expire_delete delete_func; /*< this callback is called when an element is deleted */
- expire_destroy destroy_func; /*< this callback is used for destroying all elements inside expire */
+ expire_init init_func; /*< this callback is called on kv storage initialization */
+ expire_insert insert_func; /*< this callback is called when element is inserted */
+ expire_step step_func; /*< this callback is used when cache is full */
+ expire_delete delete_func; /*< this callback is called when an element is deleted */
+ expire_destroy destroy_func; /*< this callback is used for destroying all elements inside expire */
TAILQ_HEAD (eltq, rspamd_kv_element) head;
};
static void
rspamd_lru_insert (struct rspamd_kv_expire *e, struct rspamd_kv_element *elt)
{
- struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+ struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
/* Get a proper queue */
TAILQ_INSERT_TAIL (&expire->head, elt, entry);
static void
rspamd_lru_delete (struct rspamd_kv_expire *e, struct rspamd_kv_element *elt)
{
- struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+ struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
/* Unlink element */
TAILQ_REMOVE (&expire->head, elt, entry);
* Expire elements
*/
static gboolean
-rspamd_lru_expire_step (struct rspamd_kv_expire *e, struct rspamd_kv_storage *storage, time_t now, gboolean forced)
+rspamd_lru_expire_step (struct rspamd_kv_expire *e,
+ struct rspamd_kv_storage *storage,
+ time_t now,
+ gboolean forced)
{
- struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
- struct rspamd_kv_element *elt, *oldest_elt = NULL, *temp;
- time_t diff;
- gboolean res = FALSE;
+ struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+ struct rspamd_kv_element *elt, *oldest_elt = NULL, *temp;
+ time_t diff;
+ gboolean res = FALSE;
elt = TAILQ_FIRST (&expire->head);
- if (elt && (forced || (elt->flags & (KV_ELT_PERSISTENT|KV_ELT_DIRTY)) == 0)) {
+ if (elt &&
+ (forced || (elt->flags & (KV_ELT_PERSISTENT | KV_ELT_DIRTY)) == 0)) {
diff = elt->expire - (now - elt->age);
if (diff > 0 || (forced && elt->expire == 0)) {
oldest_elt = elt;
/* This element is already expired */
storage->cache->steal_func (storage->cache, elt);
storage->memory -= ELT_SIZE (elt);
- storage->elts --;
+ storage->elts--;
TAILQ_REMOVE (&expire->head, elt, entry);
/* Free memory */
- if ((elt->flags & (KV_ELT_DIRTY|KV_ELT_NEED_INSERT)) != 0) {
+ if ((elt->flags & (KV_ELT_DIRTY | KV_ELT_NEED_INSERT)) != 0) {
elt->flags |= KV_ELT_NEED_FREE;
}
else {
}
res = TRUE;
/* Check other elements in this queue */
- TAILQ_FOREACH_SAFE (elt, &expire->head, entry, temp) {
+ TAILQ_FOREACH_SAFE (elt, &expire->head, entry, temp)
+ {
if ((!forced &&
- (elt->flags & (KV_ELT_PERSISTENT|KV_ELT_DIRTY)) != 0) || (gint)elt->expire < (now - elt->age)) {
+ (elt->flags & (KV_ELT_PERSISTENT | KV_ELT_DIRTY)) != 0) ||
+ (gint)elt->expire < (now - elt->age)) {
break;
}
storage->memory -= ELT_SIZE (elt);
- storage->elts --;
+ storage->elts--;
storage->cache->steal_func (storage->cache, elt);
TAILQ_REMOVE (&expire->head, elt, entry);
/* Free memory */
- if ((elt->flags & (KV_ELT_DIRTY|KV_ELT_NEED_INSERT)) != 0) {
+ if ((elt->flags & (KV_ELT_DIRTY | KV_ELT_NEED_INSERT)) != 0) {
elt->flags |= KV_ELT_NEED_FREE;
}
else {
if (!res && oldest_elt != NULL) {
storage->memory -= ELT_SIZE (oldest_elt);
- storage->elts --;
+ storage->elts--;
storage->cache->steal_func (storage->cache, oldest_elt);
TAILQ_REMOVE (&expire->head, oldest_elt, entry);
/* Free memory */
- if ((oldest_elt->flags & (KV_ELT_DIRTY|KV_ELT_NEED_INSERT)) != 0) {
+ if ((oldest_elt->flags & (KV_ELT_DIRTY | KV_ELT_NEED_INSERT)) != 0) {
oldest_elt->flags |= KV_ELT_NEED_FREE;
}
else {
static void
rspamd_lru_destroy (struct rspamd_kv_expire *e)
{
- struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+ struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
g_slice_free1 (sizeof (struct rspamd_kv_lru_expire), expire);
}
/**
* Create new LRU cache
*/
-struct rspamd_kv_expire*
+struct rspamd_kv_expire *
rspamd_lru_expire_new (void)
{
- struct rspamd_kv_lru_expire *new;
+ struct rspamd_kv_lru_expire *new;
new = g_slice_alloc (sizeof (struct rspamd_kv_lru_expire));
TAILQ_INIT (&new->head);
* KV cache hash table
*/
struct rspamd_kv_hash_cache {
- cache_init init_func; /*< this callback is called on kv storage initialization */
- cache_insert insert_func; /*< this callback is called when element is inserted */
- cache_replace replace_func; /*< this callback is called when element is replace */
- cache_lookup lookup_func; /*< this callback is used for lookup of element */
- cache_delete delete_func; /*< this callback is called when an element is deleted */
- cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
- cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
+ cache_init init_func; /*< this callback is called on kv storage initialization */
+ cache_insert insert_func; /*< this callback is called when element is inserted */
+ cache_replace replace_func; /*< this callback is called when element is replace */
+ cache_lookup lookup_func; /*< this callback is used for lookup of element */
+ cache_delete delete_func; /*< this callback is called when an element is deleted */
+ cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
+ cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
GHashTable *hash;
};
/**
* Insert an element inside cache
*/
-static struct rspamd_kv_element*
-rspamd_kv_hash_insert (struct rspamd_kv_cache *c, gpointer key, guint keylen, gpointer value, gsize len)
+static struct rspamd_kv_element *
+rspamd_kv_hash_insert (struct rspamd_kv_cache *c,
+ gpointer key,
+ guint keylen,
+ gpointer value,
+ gsize len)
{
- struct rspamd_kv_element *elt;
- struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
- struct rspamd_kv_element search_elt;
+ struct rspamd_kv_element *elt;
+ struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
if ((elt = g_hash_table_lookup (cache->hash, &search_elt)) == NULL) {
- elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
+ elt = g_slice_alloc (
+ sizeof (struct rspamd_kv_element) + len + keylen + 1);
elt->age = time (NULL);
elt->keylen = keylen;
elt->size = len;
elt->flags = 0;
- memcpy (ELT_KEY (elt), key, keylen + 1);
+ memcpy (ELT_KEY (elt), key, keylen + 1);
memcpy (ELT_DATA (elt), value, len);
elt->p = &elt->data;
g_hash_table_insert (cache->hash, elt, elt);
/* Free it by self */
g_slice_free1 (ELT_SIZE (elt), elt);
}
- elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
+ elt = g_slice_alloc (
+ sizeof (struct rspamd_kv_element) + len + keylen + 1);
elt->age = time (NULL);
elt->keylen = keylen;
elt->size = len;
elt->flags = 0;
- memcpy (ELT_KEY (elt), key, keylen + 1);
+ memcpy (ELT_KEY (elt), key, keylen + 1);
memcpy (ELT_DATA (elt), value, len);
elt->p = &elt->data;
g_hash_table_insert (cache->hash, elt, elt);
/**
* Lookup an item inside hash
*/
-static struct rspamd_kv_element*
+static struct rspamd_kv_element *
rspamd_kv_hash_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
{
- struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
- struct rspamd_kv_element search_elt;
+ struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
* Replace an element inside cache
*/
static gboolean
-rspamd_kv_hash_replace (struct rspamd_kv_cache *c, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_kv_hash_replace (struct rspamd_kv_cache *c,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
- struct rspamd_kv_element *oldelt, search_elt;
+ struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+ struct rspamd_kv_element *oldelt, search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
static struct rspamd_kv_element *
rspamd_kv_hash_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
{
- struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
- struct rspamd_kv_element *elt;
- struct rspamd_kv_element search_elt;
+ struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+ struct rspamd_kv_element *elt;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
static void
rspamd_kv_hash_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
{
- struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+ struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
g_hash_table_steal (cache->hash, elt);
}
static void
rspamd_kv_hash_destroy_cb (gpointer key, gpointer value, gpointer unused)
{
- struct rspamd_kv_element *elt = value;
+ struct rspamd_kv_element *elt = value;
g_slice_free1 (ELT_SIZE (elt), elt);
}
static void
rspamd_kv_hash_destroy (struct rspamd_kv_cache *c)
{
- struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+ struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
g_hash_table_foreach (cache->hash, rspamd_kv_hash_destroy_cb, NULL);
g_hash_table_destroy (cache->hash);
/**
* Make hash for element
*/
-#define rot(x,k) (((x)<<(k)) ^ ((x)>>(32-(k))))
+#define rot(x,k) (((x) << (k)) ^ ((x) >> (32 - (k))))
#define mix(a,b,c) \
-{ \
- a -= c; a ^= rot(c, 4); c += b; \
- b -= a; b ^= rot(a, 6); a += c; \
- c -= b; c ^= rot(b, 8); b += a; \
- a -= c; a ^= rot(c,16); c += b; \
- b -= a; b ^= rot(a,19); a += c; \
- c -= b; c ^= rot(b, 4); b += a; \
-}
+ { \
+ a -= c; a ^= rot (c, 4); c += b; \
+ b -= a; b ^= rot (a, 6); a += c; \
+ c -= b; c ^= rot (b, 8); b += a; \
+ a -= c; a ^= rot (c,16); c += b; \
+ b -= a; b ^= rot (a,19); a += c; \
+ c -= b; c ^= rot (b, 4); b += a; \
+ }
#define final(a,b,c) \
-{ \
- c ^= b; c -= rot(b,14); \
- a ^= c; a -= rot(c,11); \
- b ^= a; b -= rot(a,25); \
- c ^= b; c -= rot(b,16); \
- a ^= c; a -= rot(c,4); \
- b ^= a; b -= rot(a,14); \
- c ^= b; c -= rot(b,24); \
-}
+ { \
+ c ^= b; c -= rot (b,14); \
+ a ^= c; a -= rot (c,11); \
+ b ^= a; b -= rot (a,25); \
+ c ^= b; c -= rot (b,16); \
+ a ^= c; a -= rot (c,4); \
+ b ^= a; b -= rot (a,14); \
+ c ^= b; c -= rot (b,24); \
+ }
/*
* The hash function used here is by Bob Jenkins, 1996:
* <http://burtleburtle.net/bob/hash/doobs.html>
guint
kv_elt_hash_func (gconstpointer e)
{
- struct rspamd_kv_element *elt = (struct rspamd_kv_element *)e;
- guint32 a, b, c;
+ struct rspamd_kv_element *elt = (struct rspamd_kv_element *)e;
+ guint32 a, b, c;
union { const void *ptr; size_t i; } u;
- guint length;
+ guint length;
/* Set up the internal state */
length = elt->keylen;
*/
switch (length)
{
- case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
- case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
- case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
- case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
- case 8 : b+=k[1]; a+=k[0]; break;
- case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
- case 6 : b+=k[1]&0xffff; a+=k[0]; break;
- case 5 : b+=k[1]&0xff; a+=k[0]; break;
- case 4 : a+=k[0]; break;
- case 3 : a+=k[0]&0xffffff; break;
- case 2 : a+=k[0]&0xffff; break;
- case 1 : a+=k[0]&0xff; break;
- case 0 : return c; /* zero length strings require no mixing */
+ case 12: c += k[2]; b += k[1]; a += k[0]; break;
+ case 11: c += k[2] & 0xffffff; b += k[1]; a += k[0]; break;
+ case 10: c += k[2] & 0xffff; b += k[1]; a += k[0]; break;
+ case 9: c += k[2] & 0xff; b += k[1]; a += k[0]; break;
+ case 8: b += k[1]; a += k[0]; break;
+ case 7: b += k[1] & 0xffffff; a += k[0]; break;
+ case 6: b += k[1] & 0xffff; a += k[0]; break;
+ case 5: b += k[1] & 0xff; a += k[0]; break;
+ case 4: a += k[0]; break;
+ case 3: a += k[0] & 0xffffff; break;
+ case 2: a += k[0] & 0xffff; break;
+ case 1: a += k[0] & 0xff; break;
+ case 0: return c; /* zero length strings require no mixing */
}
} else if (((u.i & 0x1) == 0)) {
const guint16 *k = (const guint16 *)elt->p; /* read 16-bit chunks */
- const guint8 *k8;
+ const guint8 *k8;
/*--------------- all but last block: aligned reads and different mixing */
while (length > 12) {
- a += k[0] + (((guint32)k[1])<<16);
- b += k[2] + (((guint32)k[3])<<16);
- c += k[4] + (((guint32)k[5])<<16);
+ a += k[0] + (((guint32)k[1]) << 16);
+ b += k[2] + (((guint32)k[3]) << 16);
+ c += k[4] + (((guint32)k[5]) << 16);
mix (a,b,c);
length -= 12;
k += 6;
k8 = (const guint8 *)k;
switch (length)
{
- case 12: c+=k[4]+(((guint32)k[5])<<16);
- b+=k[2]+(((guint32)k[3])<<16);
- a+=k[0]+(((guint32)k[1])<<16);
- break;
- case 11: c+=((guint32)k8[10])<<16; /* @fallthrough */
- case 10: c+=k[4]; /* @fallthrough@ */
- b+=k[2]+(((guint32)k[3])<<16);
- a+=k[0]+(((guint32)k[1])<<16);
- break;
- case 9 : c+=k8[8]; /* @fallthrough */
- case 8 : b+=k[2]+(((guint32)k[3])<<16);
- a+=k[0]+(((guint32)k[1])<<16);
- break;
- case 7 : b+=((guint32)k8[6])<<16; /* @fallthrough */
- case 6 : b+=k[2];
- a+=k[0]+(((guint32)k[1])<<16);
- break;
- case 5 : b+=k8[4]; /* @fallthrough */
- case 4 : a+=k[0]+(((guint32)k[1])<<16);
- break;
- case 3 : a+=((guint32)k8[2])<<16; /* @fallthrough */
- case 2 : a+=k[0];
- break;
- case 1 : a+=k8[0];
- break;
- case 0 : return c; /* zero length strings require no mixing */
+ case 12: c += k[4] + (((guint32)k[5]) << 16);
+ b += k[2] + (((guint32)k[3]) << 16);
+ a += k[0] + (((guint32)k[1]) << 16);
+ break;
+ case 11: c += ((guint32)k8[10]) << 16; /* @fallthrough */
+ case 10: c += k[4]; /* @fallthrough@ */
+ b += k[2] + (((guint32)k[3]) << 16);
+ a += k[0] + (((guint32)k[1]) << 16);
+ break;
+ case 9: c += k8[8]; /* @fallthrough */
+ case 8: b += k[2] + (((guint32)k[3]) << 16);
+ a += k[0] + (((guint32)k[1]) << 16);
+ break;
+ case 7: b += ((guint32)k8[6]) << 16; /* @fallthrough */
+ case 6: b += k[2];
+ a += k[0] + (((guint32)k[1]) << 16);
+ break;
+ case 5: b += k8[4]; /* @fallthrough */
+ case 4: a += k[0] + (((guint32)k[1]) << 16);
+ break;
+ case 3: a += ((guint32)k8[2]) << 16; /* @fallthrough */
+ case 2: a += k[0];
+ break;
+ case 1: a += k8[0];
+ break;
+ case 0: return c; /* zero length strings require no mixing */
}
} else { /* need to read the key one byte at a time */
while (length > 12)
{
a += k[0];
- a += ((guint32)k[1])<<8;
- a += ((guint32)k[2])<<16;
- a += ((guint32)k[3])<<24;
+ a += ((guint32)k[1]) << 8;
+ a += ((guint32)k[2]) << 16;
+ a += ((guint32)k[3]) << 24;
b += k[4];
- b += ((guint32)k[5])<<8;
- b += ((guint32)k[6])<<16;
- b += ((guint32)k[7])<<24;
+ b += ((guint32)k[5]) << 8;
+ b += ((guint32)k[6]) << 16;
+ b += ((guint32)k[7]) << 24;
c += k[8];
- c += ((guint32)k[9])<<8;
- c += ((guint32)k[10])<<16;
- c += ((guint32)k[11])<<24;
- mix(a,b,c);
+ c += ((guint32)k[9]) << 8;
+ c += ((guint32)k[10]) << 16;
+ c += ((guint32)k[11]) << 24;
+ mix (a,b,c);
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch (length) /* all the case statements fall through */
{
- case 12: c+=((guint32)k[11])<<24;
- case 11: c+=((guint32)k[10])<<16;
- case 10: c+=((guint32)k[9])<<8;
- case 9 : c+=k[8];
- case 8 : b+=((guint32)k[7])<<24;
- case 7 : b+=((guint32)k[6])<<16;
- case 6 : b+=((guint32)k[5])<<8;
- case 5 : b+=k[4];
- case 4 : a+=((guint32)k[3])<<24;
- case 3 : a+=((guint32)k[2])<<16;
- case 2 : a+=((guint32)k[1])<<8;
- case 1 : a+=k[0];
- break;
- case 0 : return c; /* zero length strings require no mixing */
+ case 12: c += ((guint32)k[11]) << 24;
+ case 11: c += ((guint32)k[10]) << 16;
+ case 10: c += ((guint32)k[9]) << 8;
+ case 9: c += k[8];
+ case 8: b += ((guint32)k[7]) << 24;
+ case 7: b += ((guint32)k[6]) << 16;
+ case 6: b += ((guint32)k[5]) << 8;
+ case 5: b += k[4];
+ case 4: a += ((guint32)k[3]) << 24;
+ case 3: a += ((guint32)k[2]) << 16;
+ case 2: a += ((guint32)k[1]) << 8;
+ case 1: a += k[0];
+ break;
+ case 0: return c; /* zero length strings require no mixing */
}
}
gboolean
kv_elt_compare_func (gconstpointer e1, gconstpointer e2)
{
- struct rspamd_kv_element *elt1 = (struct rspamd_kv_element *) e1,
- *elt2 = (struct rspamd_kv_element *) e2;
+ struct rspamd_kv_element *elt1 = (struct rspamd_kv_element *) e1,
+ *elt2 = (struct rspamd_kv_element *) e2;
if (elt1->keylen == elt2->keylen) {
return memcmp (elt1->p, elt2->p, elt1->keylen) == 0;
/**
* Create new hash kv cache
*/
-struct rspamd_kv_cache*
+struct rspamd_kv_cache *
rspamd_kv_hash_new (void)
{
- struct rspamd_kv_hash_cache *new;
+ struct rspamd_kv_hash_cache *new;
new = g_slice_alloc (sizeof (struct rspamd_kv_hash_cache));
- new->hash = g_hash_table_new_full (kv_elt_hash_func, kv_elt_compare_func, NULL, NULL);
+ new->hash = g_hash_table_new_full (kv_elt_hash_func,
+ kv_elt_compare_func,
+ NULL,
+ NULL);
new->init_func = NULL;
new->insert_func = rspamd_kv_hash_insert;
new->lookup_func = rspamd_kv_hash_lookup;
* Radix cache hash table
*/
struct rspamd_kv_radix_cache {
- cache_init init_func; /*< this callback is called on kv storage initialization */
- cache_insert insert_func; /*< this callback is called when element is inserted */
- cache_replace replace_func; /*< this callback is called when element is replace */
- cache_lookup lookup_func; /*< this callback is used for lookup of element */
- cache_delete delete_func; /*< this callback is called when an element is deleted */
- cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
- cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
+ cache_init init_func; /*< this callback is called on kv storage initialization */
+ cache_insert insert_func; /*< this callback is called when element is inserted */
+ cache_replace replace_func; /*< this callback is called when element is replace */
+ cache_lookup lookup_func; /*< this callback is used for lookup of element */
+ cache_delete delete_func; /*< this callback is called when an element is deleted */
+ cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
+ cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
radix_tree_t *tree;
};
static guint32
rspamd_kv_radix_validate (gpointer key, guint keylen)
{
- struct in_addr addr;
+ struct in_addr addr;
if (inet_aton (key, &addr) == 0) {
return 0;
/**
* Insert an element inside cache
*/
-static struct rspamd_kv_element*
-rspamd_kv_radix_insert (struct rspamd_kv_cache *c, gpointer key, guint keylen, gpointer value, gsize len)
+static struct rspamd_kv_element *
+rspamd_kv_radix_insert (struct rspamd_kv_cache *c,
+ gpointer key,
+ guint keylen,
+ gpointer value,
+ gsize len)
{
- struct rspamd_kv_element *elt;
- struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
- guint32 rkey = rspamd_kv_radix_validate (key, keylen);
+ struct rspamd_kv_element *elt;
+ struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+ guint32 rkey = rspamd_kv_radix_validate (key, keylen);
if (rkey == 0) {
return NULL;
elt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
if ((uintptr_t)elt == RADIX_NO_VALUE) {
- elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
+ elt = g_slice_alloc (
+ sizeof (struct rspamd_kv_element) + len + keylen + 1);
elt->age = time (NULL);
elt->keylen = keylen;
elt->size = len;
elt->flags = 0;
- memcpy (ELT_KEY (elt), key, keylen + 1);
+ memcpy (ELT_KEY (elt), key, keylen + 1);
memcpy (ELT_DATA (elt), value, len);
elt->p = &elt->data;
radix32tree_insert (cache->tree, rkey, 0xffffffff, (uintptr_t)elt);
/* Free it by self */
g_slice_free1 (ELT_SIZE (elt), elt);
}
- elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
+ elt = g_slice_alloc (
+ sizeof (struct rspamd_kv_element) + len + keylen + 1);
elt->age = time (NULL);
elt->keylen = keylen;
elt->size = len;
elt->flags = 0;
- memcpy (ELT_KEY (elt), key, keylen + 1);
+ memcpy (ELT_KEY (elt), key, keylen + 1);
memcpy (ELT_DATA (elt), value, len);
elt->p = &elt->data;
radix32tree_insert (cache->tree, rkey, 0xffffffff, (uintptr_t)elt);
/**
* Lookup an item inside radix
*/
-static struct rspamd_kv_element*
+static struct rspamd_kv_element *
rspamd_kv_radix_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
{
- struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
- guint32 rkey = rspamd_kv_radix_validate (key, keylen);
- struct rspamd_kv_element *elt;
+ struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+ guint32 rkey = rspamd_kv_radix_validate (key, keylen);
+ struct rspamd_kv_element *elt;
elt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
if ((uintptr_t)elt == RADIX_NO_VALUE) {
* Replace an element inside cache
*/
static gboolean
-rspamd_kv_radix_replace (struct rspamd_kv_cache *c, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_kv_radix_replace (struct rspamd_kv_cache *c,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
- guint32 rkey = rspamd_kv_radix_validate (key, keylen);
- struct rspamd_kv_element *oldelt;
+ struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+ guint32 rkey = rspamd_kv_radix_validate (key, keylen);
+ struct rspamd_kv_element *oldelt;
oldelt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
if ((uintptr_t)oldelt != RADIX_NO_VALUE) {
static struct rspamd_kv_element *
rspamd_kv_radix_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
{
- struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
- struct rspamd_kv_element *elt;
- guint32 rkey = rspamd_kv_radix_validate (key, keylen);
+ struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+ struct rspamd_kv_element *elt;
+ guint32 rkey = rspamd_kv_radix_validate (key, keylen);
elt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
if ((uintptr_t)elt != RADIX_NO_VALUE) {
static void
rspamd_kv_radix_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
{
- struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
- guint32 rkey = rspamd_kv_radix_validate (ELT_KEY (elt), elt->keylen);
+ struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+ guint32 rkey = rspamd_kv_radix_validate (ELT_KEY (elt), elt->keylen);
radix32tree_delete (cache->tree, rkey, 0xffffffff);
static void
rspamd_kv_radix_destroy (struct rspamd_kv_cache *c)
{
- struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+ struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
radix_tree_free (cache->tree);
g_slice_free1 (sizeof (struct rspamd_kv_radix_cache), cache);
/**
* Create new radix kv cache
*/
-struct rspamd_kv_cache*
+struct rspamd_kv_cache *
rspamd_kv_radix_new (void)
{
- struct rspamd_kv_radix_cache *new;
+ struct rspamd_kv_radix_cache *new;
new = g_slice_alloc (sizeof (struct rspamd_kv_radix_cache));
new->tree = radix_tree_create ();
* KV cache hash table
*/
struct rspamd_kv_judy_cache {
- cache_init init_func; /*< this callback is called on kv storage initialization */
- cache_insert insert_func; /*< this callback is called when element is inserted */
- cache_replace replace_func; /*< this callback is called when element is replace */
- cache_lookup lookup_func; /*< this callback is used for lookup of element */
- cache_delete delete_func; /*< this callback is called when an element is deleted */
- cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
- cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
+ cache_init init_func; /*< this callback is called on kv storage initialization */
+ cache_insert insert_func; /*< this callback is called when element is inserted */
+ cache_replace replace_func; /*< this callback is called when element is replace */
+ cache_lookup lookup_func; /*< this callback is used for lookup of element */
+ cache_delete delete_func; /*< this callback is called when an element is deleted */
+ cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
+ cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
Pvoid_t judy;
};
/**
* Lookup an item inside judy
*/
-static struct rspamd_kv_element*
+static struct rspamd_kv_element *
rspamd_kv_judy_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
{
- struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
- struct rspamd_kv_element *elt = NULL, **pelt;
+ struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+ struct rspamd_kv_element *elt = NULL, **pelt;
JHSG (pelt, cache->judy, key, keylen);
if (pelt != NULL) {
static struct rspamd_kv_element *
rspamd_kv_judy_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
{
- struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
- struct rspamd_kv_element *elt;
- gint rc;
+ struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+ struct rspamd_kv_element *elt;
+ gint rc;
elt = rspamd_kv_judy_lookup (c, key, keylen);
if (elt) {
static void
rspamd_kv_judy_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
{
- struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
- gint rc;
+ struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+ gint rc;
JHSD (rc, cache->judy, ELT_KEY (elt), elt->keylen);
}
/**
* Insert an element inside cache
*/
-static struct rspamd_kv_element*
-rspamd_kv_judy_insert (struct rspamd_kv_cache *c, gpointer key, guint keylen, gpointer value, gsize len)
+static struct rspamd_kv_element *
+rspamd_kv_judy_insert (struct rspamd_kv_cache *c,
+ gpointer key,
+ guint keylen,
+ gpointer value,
+ gsize len)
{
- struct rspamd_kv_element *elt, **pelt;
- struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+ struct rspamd_kv_element *elt, **pelt;
+ struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
if ((elt = rspamd_kv_judy_lookup (c, key, keylen)) == NULL) {
- elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
+ elt = g_slice_alloc (
+ sizeof (struct rspamd_kv_element) + len + keylen + 1);
elt->age = time (NULL);
elt->keylen = keylen;
elt->size = len;
elt->flags = 0;
- memcpy (ELT_KEY (elt), key, keylen);
+ memcpy (ELT_KEY (elt), key, keylen);
memcpy (ELT_DATA (elt), value, len);
JHSI (pelt, cache->judy, ELT_KEY (elt), elt->keylen);
elt->p = &elt->data;
/* Free it by self */
g_slice_free1 (ELT_SIZE (elt), elt);
}
- elt = g_slice_alloc0 (sizeof (struct rspamd_kv_element) + len + keylen + 1);
+ elt = g_slice_alloc0 (
+ sizeof (struct rspamd_kv_element) + len + keylen + 1);
elt->age = time (NULL);
elt->keylen = keylen;
elt->size = len;
elt->flags = 0;
- memcpy (ELT_KEY (elt), key, keylen);
+ memcpy (ELT_KEY (elt), key, keylen);
memcpy (ELT_DATA (elt), value, len);
elt->p = &elt->data;
JHSI (pelt, cache->judy, ELT_KEY (elt), elt->keylen);
* Replace an element inside cache
*/
static gboolean
-rspamd_kv_judy_replace (struct rspamd_kv_cache *c, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_kv_judy_replace (struct rspamd_kv_cache *c,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
- struct rspamd_kv_element *oldelt, **pelt;
+ struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+ struct rspamd_kv_element *oldelt, **pelt;
if ((oldelt = rspamd_kv_judy_lookup (c, key, keylen)) != NULL) {
rspamd_kv_judy_steal (c, elt);
static void
rspamd_kv_judy_destroy (struct rspamd_kv_cache *c)
{
- struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
- glong bytes;
+ struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+ glong bytes;
JHSFA (bytes, cache->judy);
g_slice_free1 (sizeof (struct rspamd_kv_judy_cache), cache);
/**
* Judy tree
*/
-struct rspamd_kv_cache*
+struct rspamd_kv_cache *
rspamd_kv_judy_new (void)
{
- struct rspamd_kv_judy_cache *new;
+ struct rspamd_kv_judy_cache *new;
new = g_slice_alloc (sizeof (struct rspamd_kv_judy_cache));
new->judy = NULL;
/* Callbacks for cache */
typedef void (*cache_init)(struct rspamd_kv_cache *cache);
-typedef struct rspamd_kv_element* (*cache_insert)(struct rspamd_kv_cache *cache,
- gpointer key, guint keylen, gpointer value, gsize len);
-typedef gboolean (*cache_replace)(struct rspamd_kv_cache *cache, gpointer key, guint keylen,
- struct rspamd_kv_element *elt);
-typedef struct rspamd_kv_element* (*cache_lookup)(struct rspamd_kv_cache *cache, gpointer key, guint keylen);
-typedef struct rspamd_kv_element* (*cache_delete)(struct rspamd_kv_cache *cache, gpointer key, guint keylen);
-typedef void (*cache_steal)(struct rspamd_kv_cache *cache, struct rspamd_kv_element* elt);
+typedef struct rspamd_kv_element * (*cache_insert)(struct rspamd_kv_cache *cache,
+ gpointer key, guint keylen, gpointer value, gsize len);
+typedef gboolean (*cache_replace)(struct rspamd_kv_cache *cache, gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt);
+typedef struct rspamd_kv_element * (*cache_lookup)(struct rspamd_kv_cache *cache,
+ gpointer key, guint keylen);
+typedef struct rspamd_kv_element * (*cache_delete)(struct rspamd_kv_cache *cache,
+ gpointer key, guint keylen);
+typedef void (*cache_steal)(struct rspamd_kv_cache *cache,
+ struct rspamd_kv_element * elt);
typedef void (*cache_destroy)(struct rspamd_kv_cache *cache);
/* Callbacks for backend */
typedef void (*backend_init)(struct rspamd_kv_backend *backend);
-typedef gboolean (*backend_insert)(struct rspamd_kv_backend *backend, gpointer key, guint keylen,
- struct rspamd_kv_element *elt);
-typedef gboolean (*backend_replace)(struct rspamd_kv_backend *backend, gpointer key, guint keylen,
- struct rspamd_kv_element *elt);
-typedef struct rspamd_kv_element* (*backend_lookup)(struct rspamd_kv_backend *backend, gpointer key,
- guint keylen);
-typedef void (*backend_delete)(struct rspamd_kv_backend *backend, gpointer key, guint keylen);
+typedef gboolean (*backend_insert)(struct rspamd_kv_backend *backend,
+ gpointer key, guint keylen,
+ struct rspamd_kv_element *elt);
+typedef gboolean (*backend_replace)(struct rspamd_kv_backend *backend,
+ gpointer key, guint keylen,
+ struct rspamd_kv_element *elt);
+typedef struct rspamd_kv_element * (*backend_lookup)(struct rspamd_kv_backend *
+ backend, gpointer key,
+ guint keylen);
+typedef void (*backend_delete)(struct rspamd_kv_backend *backend, gpointer key,
+ guint keylen);
typedef gboolean (*backend_sync)(struct rspamd_kv_backend *backend);
-typedef gboolean (*backend_incref)(struct rspamd_kv_backend *backend, gpointer key, guint keylen);
+typedef gboolean (*backend_incref)(struct rspamd_kv_backend *backend,
+ gpointer key, guint keylen);
typedef void (*backend_destroy)(struct rspamd_kv_backend *backend);
/* Callbacks for expire */
typedef void (*expire_init)(struct rspamd_kv_expire *expire);
-typedef void (*expire_insert)(struct rspamd_kv_expire *expire, struct rspamd_kv_element *elt);
-typedef void (*expire_delete)(struct rspamd_kv_expire *expire, struct rspamd_kv_element *elt);
-typedef gboolean (*expire_step)(struct rspamd_kv_expire *expire, struct rspamd_kv_storage *storage,
- time_t now, gboolean forced);
+typedef void (*expire_insert)(struct rspamd_kv_expire *expire,
+ struct rspamd_kv_element *elt);
+typedef void (*expire_delete)(struct rspamd_kv_expire *expire,
+ struct rspamd_kv_element *elt);
+typedef gboolean (*expire_step)(struct rspamd_kv_expire *expire,
+ struct rspamd_kv_storage *storage,
+ time_t now, gboolean forced);
typedef void (*expire_destroy)(struct rspamd_kv_expire *expire);
#define ELT_DATA(elt) (gchar *)(elt)->data + (elt)->keylen + 1
#define ELT_LONG(elt) *((glong *)((elt)->data + (elt)->keylen + 1))
#define ELT_KEY(elt) (gchar *)(elt)->data
-#define ELT_SIZE(elt) elt->size + sizeof(struct rspamd_kv_element) + elt->keylen + 1
+#define ELT_SIZE(elt) elt->size + sizeof(struct rspamd_kv_element) + \
+ elt->keylen + 1
/* Common structures description */
struct rspamd_kv_element {
- time_t age; /*< age of element */
- guint32 expire; /*< expire of element */
- gint flags; /*< element flags */
- gsize size; /*< size of element */
- TAILQ_ENTRY (rspamd_kv_element) entry; /*< list entry */
- guint keylen; /*< length of key */
-
- gpointer p; /*< pointer to data */
- gchar data[1]; /*< expandable data */
+ time_t age; /*< age of element */
+ guint32 expire; /*< expire of element */
+ gint flags; /*< element flags */
+ gsize size; /*< size of element */
+ TAILQ_ENTRY (rspamd_kv_element) entry; /*< list entry */
+ guint keylen; /*< length of key */
+
+ gpointer p; /*< pointer to data */
+ gchar data[1]; /*< expandable data */
};
struct rspamd_kv_cache {
- cache_init init_func; /*< this callback is called on kv storage initialization */
- cache_insert insert_func; /*< this callback is called when element is inserted */
- cache_replace replace_func; /*< this callback is called when element is replace */
- cache_lookup lookup_func; /*< this callback is used for lookup of element */
- cache_delete delete_func; /*< this callback is called when an element is deleted */
- cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
- cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
+ cache_init init_func; /*< this callback is called on kv storage initialization */
+ cache_insert insert_func; /*< this callback is called when element is inserted */
+ cache_replace replace_func; /*< this callback is called when element is replace */
+ cache_lookup lookup_func; /*< this callback is used for lookup of element */
+ cache_delete delete_func; /*< this callback is called when an element is deleted */
+ cache_steal steal_func; /*< this callback is used to replace duplicates in cache */
+ cache_destroy destroy_func; /*< this callback is used for destroying all elements inside cache */
};
struct rspamd_kv_backend {
- backend_init init_func; /*< this callback is called on kv storage initialization */
- backend_insert insert_func; /*< this callback is called when element is inserted */
- backend_replace replace_func; /*< this callback is called when element is replaced */
- backend_lookup lookup_func; /*< this callback is used for lookup of element */
- backend_delete delete_func; /*< this callback is called when an element is deleted */
- backend_sync sync_func; /*< this callback is called when backend need to be synced */
- backend_incref incref_func; /*< this callback is called when element must be ref'd */
- backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
+ backend_init init_func; /*< this callback is called on kv storage initialization */
+ backend_insert insert_func; /*< this callback is called when element is inserted */
+ backend_replace replace_func; /*< this callback is called when element is replaced */
+ backend_lookup lookup_func; /*< this callback is used for lookup of element */
+ backend_delete delete_func; /*< this callback is called when an element is deleted */
+ backend_sync sync_func; /*< this callback is called when backend need to be synced */
+ backend_incref incref_func; /*< this callback is called when element must be ref'd */
+ backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
};
struct rspamd_kv_expire {
- expire_init init_func; /*< this callback is called on kv storage initialization */
- expire_insert insert_func; /*< this callback is called when element is inserted */
- expire_step step_func; /*< this callback is used when cache is full */
- expire_delete delete_func; /*< this callback is called when an element is deleted */
- expire_destroy destroy_func; /*< this callback is used for destroying all elements inside expire */
+ expire_init init_func; /*< this callback is called on kv storage initialization */
+ expire_insert insert_func; /*< this callback is called when element is inserted */
+ expire_step step_func; /*< this callback is used when cache is full */
+ expire_delete delete_func; /*< this callback is called when an element is deleted */
+ expire_destroy destroy_func; /*< this callback is used for destroying all elements inside expire */
};
/* Main kv storage structure */
struct rspamd_kv_backend *backend;
struct rspamd_kv_expire *expire;
- gsize elts; /*< current elements count in a storage */
- gsize max_elts; /*< maximum number of elements in a storage */
+ gsize elts; /*< current elements count in a storage */
+ gsize max_elts; /*< maximum number of elements in a storage */
- gsize memory; /*< memory eaten */
- gsize max_memory; /*< memory limit */
+ gsize memory; /*< memory eaten */
+ gsize max_memory; /*< memory limit */
- gint id; /* char ID */
- gchar *name; /* numeric ID */
+ gint id; /* char ID */
+ gchar *name; /* numeric ID */
- gboolean no_overwrite; /* do not overwrite data with the same keys */
+ gboolean no_overwrite; /* do not overwrite data with the same keys */
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION > 30))
- GRWLock rwlock; /* rwlock in new glib */
+ GRWLock rwlock; /* rwlock in new glib */
#else
- GStaticRWLock rwlock; /* rwlock for threaded access */
+ GStaticRWLock rwlock; /* rwlock for threaded access */
#endif
};
/** Create new kv storage */
-struct rspamd_kv_storage *rspamd_kv_storage_new (gint id, const gchar *name,
- struct rspamd_kv_cache *cache, struct rspamd_kv_backend *backend,
- struct rspamd_kv_expire *expire,
- gsize max_elts, gsize max_memory, gboolean no_overwrite);
+struct rspamd_kv_storage * rspamd_kv_storage_new (gint id, const gchar *name,
+ struct rspamd_kv_cache *cache, struct rspamd_kv_backend *backend,
+ struct rspamd_kv_expire *expire,
+ gsize max_elts, gsize max_memory, gboolean no_overwrite);
/** Insert new element to the kv storage */
-gboolean rspamd_kv_storage_insert (struct rspamd_kv_storage *storage, gpointer key, guint keylen, gpointer data, gsize len, gint flags, guint expire);
+gboolean rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ gpointer data,
+ gsize len,
+ gint flags,
+ guint expire);
/** Insert element only in cache */
-gboolean rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
- gpointer data, gsize len, gint flags, guint expire, struct rspamd_kv_element **pelt);
+gboolean rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ gpointer data,
+ gsize len,
+ gint flags,
+ guint expire,
+ struct rspamd_kv_element **pelt);
/** Replace an element in the kv storage */
-gboolean rspamd_kv_storage_replace (struct rspamd_kv_storage *storage, gpointer key, guint keylen, struct rspamd_kv_element *elt);
+gboolean rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt);
/** Increment value in kvstorage */
-gboolean rspamd_kv_storage_increment (struct rspamd_kv_storage *storage, gpointer key, guint keylen, glong *value);
+gboolean rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ glong *value);
/** Lookup an element inside kv storage */
-struct rspamd_kv_element* rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage, gpointer key, guint keylen, time_t now);
+struct rspamd_kv_element * rspamd_kv_storage_lookup (
+ struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ time_t now);
/** Expire an element from kv storage */
-struct rspamd_kv_element* rspamd_kv_storage_delete (struct rspamd_kv_storage *storage, gpointer key, guint keylen);
+struct rspamd_kv_element * rspamd_kv_storage_delete (
+ struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen);
/** Destroy kv storage */
void rspamd_kv_storage_destroy (struct rspamd_kv_storage *storage);
/** Insert array */
-gboolean rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen, guint elt_size, gpointer data, gsize len, gint flags, guint expire);
+gboolean rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ guint elt_size,
+ gpointer data,
+ gsize len,
+ gint flags,
+ guint expire);
/** Set element inside array */
-gboolean rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen, guint elt_num,
- gpointer data, gsize len, time_t now);
+gboolean rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ guint elt_num,
+ gpointer data,
+ gsize len,
+ time_t now);
/** Get element inside array */
-gboolean rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen, guint elt_num,
- gpointer *data, gsize *len, time_t now);
+gboolean rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage,
+ gpointer key,
+ guint keylen,
+ guint elt_num,
+ gpointer *data,
+ gsize *len,
+ time_t now);
/* Hash table functions */
guint kv_elt_hash_func (gconstpointer e);
/**
* LRU expire
*/
-struct rspamd_kv_expire* rspamd_lru_expire_new (void);
+struct rspamd_kv_expire * rspamd_lru_expire_new (void);
/**
* Ordinary hash
*/
-struct rspamd_kv_cache* rspamd_kv_hash_new (void);
+struct rspamd_kv_cache * rspamd_kv_hash_new (void);
/**
* Radix tree
*/
-struct rspamd_kv_cache* rspamd_kv_radix_new (void);
+struct rspamd_kv_cache * rspamd_kv_radix_new (void);
#ifdef WITH_JUDY
/**
* Judy tree
*/
-struct rspamd_kv_cache* rspamd_kv_judy_new (void);
+struct rspamd_kv_cache * rspamd_kv_judy_new (void);
#endif
#endif /* KVSTORAGE_H_ */
#include "config.h"
#include "kvstorage.h"
#include "kvstorage_bdb.h"
-#include "util.h"
#include "main.h"
+#include "util.h"
#include <db.h>
struct bdb_op {
/* Main bdb structure */
struct rspamd_bdb_backend {
- backend_init init_func; /*< this callback is called on kv storage initialization */
- backend_insert insert_func; /*< this callback is called when element is inserted */
- backend_replace replace_func; /*< this callback is called when element is replaced */
- backend_lookup lookup_func; /*< this callback is used for lookup of element */
- backend_delete delete_func; /*< this callback is called when an element is deleted */
- backend_sync sync_func; /*< this callback is called when backend need to be synced */
- backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
- DB_ENV *envp; /*< db environment */
- DB *dbp; /*< db pointer */
+ backend_init init_func; /*< this callback is called on kv storage initialization */
+ backend_insert insert_func; /*< this callback is called when element is inserted */
+ backend_replace replace_func; /*< this callback is called when element is replaced */
+ backend_lookup lookup_func; /*< this callback is used for lookup of element */
+ backend_delete delete_func; /*< this callback is called when an element is deleted */
+ backend_sync sync_func; /*< this callback is called when backend need to be synced */
+ backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
+ DB_ENV *envp; /*< db environment */
+ DB *dbp; /*< db pointer */
gchar *filename;
gchar *dirname;
guint sync_ops;
/* Process single bdb operation */
static gboolean
-bdb_process_single_op (struct rspamd_bdb_backend *db, DB_TXN *txn, struct bdb_op *op)
+bdb_process_single_op (struct rspamd_bdb_backend *db,
+ DB_TXN *txn,
+ struct bdb_op *op)
{
- DBT db_key, db_data;
+ DBT db_key, db_data;
- memset (&db_key, 0, sizeof(DBT));
+ memset (&db_key, 0, sizeof(DBT));
memset (&db_data, 0, sizeof(DBT));
db_key.size = op->elt->keylen;
db_key.data = ELT_KEY (op->elt);
- db_data.size = op->elt->size + sizeof (struct rspamd_kv_element) + op->elt->keylen + 1;
+ db_data.size = op->elt->size + sizeof (struct rspamd_kv_element) +
+ op->elt->keylen + 1;
db_data.data = op->elt;
switch (op->op) {
static gboolean
bdb_process_queue (struct rspamd_kv_backend *backend)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
- struct bdb_op *op;
- GList *cur;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ struct bdb_op *op;
+ GList *cur;
cur = db->ops_queue->head;
while (cur) {
op = cur->data;
- if (! bdb_process_single_op (db, NULL, op)) {
+ if (!bdb_process_single_op (db, NULL, op)) {
return FALSE;
}
cur = g_list_next (cur);
cur = db->ops_queue->head;
while (cur) {
op = cur->data;
- if (op->op == BDB_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
+ if (op->op == BDB_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
+ 0) {
/* Also clean memory */
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
}
static void
rspamd_bdb_init (struct rspamd_kv_backend *backend)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
- guint32 flags;
- gint ret;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ guint32 flags;
+ gint ret;
if ((ret = db_env_create (&db->envp, 0)) != 0) {
/* Cannot create environment */
}
flags = DB_INIT_MPOOL |
- DB_CREATE | /* Create the environment if it does not already exist. */
- DB_INIT_LOCK | /* Initialize locking. */
- DB_THREAD; /* Use threads */
+ DB_CREATE | /* Create the environment if it does not already exist. */
+ DB_INIT_LOCK | /* Initialize locking. */
+ DB_THREAD; /* Use threads */
if ((ret = db->envp->open (db->envp, db->dirname, flags, 0)) != 0) {
/* Cannot open environment */
goto err;
}
- if ((ret = db->dbp->open (db->dbp, NULL, db->filename, NULL, DB_HASH, flags, 0)) != 0) {
+ if ((ret =
+ db->dbp->open (db->dbp, NULL, db->filename, NULL, DB_HASH, flags,
+ 0)) != 0) {
goto err;
}
}
static gboolean
-rspamd_bdb_insert (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_bdb_insert (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
- struct bdb_op *op;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ struct bdb_op *op;
if (!db->initialized) {
return FALSE;
g_queue_push_head (db->ops_queue, op);
g_hash_table_insert (db->ops_hash, elt, op);
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
return bdb_process_queue (backend);
}
}
static gboolean
-rspamd_bdb_replace (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_bdb_replace (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
- struct bdb_op *op;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ struct bdb_op *op;
if (!db->initialized) {
return FALSE;
g_queue_push_head (db->ops_queue, op);
g_hash_table_insert (db->ops_hash, elt, op);
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
return bdb_process_queue (backend);
}
return TRUE;
}
-static struct rspamd_kv_element*
-rspamd_bdb_lookup (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+static struct rspamd_kv_element *
+rspamd_bdb_lookup (struct rspamd_kv_backend *backend, gpointer key,
+ guint keylen)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
- struct bdb_op *op;
- DBT db_key, db_data;
- struct rspamd_kv_element *elt = NULL;
- struct rspamd_kv_element search_elt;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ struct bdb_op *op;
+ DBT db_key, db_data;
+ struct rspamd_kv_element *elt = NULL;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
return op->elt;
}
- memset (&db_key, 0, sizeof(DBT));
+ memset (&db_key, 0, sizeof(DBT));
memset (&db_data, 0, sizeof(DBT));
db_key.size = keylen;
db_key.data = key;
}
static void
-rspamd_bdb_delete (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+rspamd_bdb_delete (struct rspamd_kv_backend *backend, gpointer key,
+ guint keylen)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
- struct bdb_op *op;
- struct rspamd_kv_element *elt;
- struct rspamd_kv_element search_elt;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ struct bdb_op *op;
+ struct rspamd_kv_element *elt;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
g_queue_push_head (db->ops_queue, op);
g_hash_table_insert (db->ops_hash, elt, op);
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
bdb_process_queue (backend);
}
static void
rspamd_bdb_destroy (struct rspamd_kv_backend *backend)
{
- struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+ struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
if (db->initialized) {
bdb_process_queue (backend);
struct rspamd_kv_backend *
rspamd_kv_bdb_new (const gchar *filename, guint sync_ops)
{
- struct rspamd_bdb_backend *new;
- struct stat st;
- gchar *dirname;
+ struct rspamd_bdb_backend *new;
+ struct stat st;
+ gchar *dirname;
if (filename == NULL) {
return NULL;
#ifdef WITH_DB
/* Create new bdb backend */
-struct rspamd_kv_backend* rspamd_kv_bdb_new (const gchar *filename, guint sync_ops);
+struct rspamd_kv_backend * rspamd_kv_bdb_new (const gchar *filename,
+ guint sync_ops);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "cfg_xml.h"
#include "kvstorage_config.h"
#include "main.h"
-#include "cfg_xml.h"
#ifdef WITH_DB
#include "kvstorage_bdb.h"
#endif
static void
kvstorage_config_destroy (gpointer k)
{
- struct kvstorage_config *kconf = k;
+ struct kvstorage_config *kconf = k;
if (kconf->name) {
g_free (kconf->name);
/* Init kvstorage */
static void
-kvstorage_init_callback (const gpointer key, const gpointer value, gpointer unused)
+kvstorage_init_callback (const gpointer key,
+ const gpointer value,
+ gpointer unused)
{
- struct kvstorage_config *kconf = value;
- struct rspamd_kv_cache *cache;
- struct rspamd_kv_backend *backend = NULL;
- struct rspamd_kv_expire *expire = NULL;
+ struct kvstorage_config *kconf = value;
+ struct rspamd_kv_cache *cache;
+ struct rspamd_kv_backend *backend = NULL;
+ struct rspamd_kv_expire *expire = NULL;
switch (kconf->cache.type) {
case KVSTORAGE_TYPE_CACHE_HASH:
backend = NULL;
break;
case KVSTORAGE_TYPE_BACKEND_FILE:
- backend = rspamd_kv_file_new (kconf->backend.filename, kconf->backend.sync_ops,
- FILE_STORAGE_LEVELS, kconf->backend.do_fsync, kconf->backend.do_ref);
+ backend = rspamd_kv_file_new (kconf->backend.filename,
+ kconf->backend.sync_ops,
+ FILE_STORAGE_LEVELS,
+ kconf->backend.do_fsync,
+ kconf->backend.do_ref);
break;
#ifdef WITH_DB
case KVSTORAGE_TYPE_BACKEND_BDB:
- backend = rspamd_kv_bdb_new (kconf->backend.filename, kconf->backend.sync_ops);
+ backend = rspamd_kv_bdb_new (kconf->backend.filename,
+ kconf->backend.sync_ops);
break;
#endif
#ifdef WITH_SQLITE
case KVSTORAGE_TYPE_BACKEND_SQLITE:
- backend = rspamd_kv_sqlite_new (kconf->backend.filename, kconf->backend.sync_ops);
+ backend = rspamd_kv_sqlite_new (kconf->backend.filename,
+ kconf->backend.sync_ops);
break;
#endif
}
break;
}
- kconf->storage = rspamd_kv_storage_new (kconf->id, kconf->name, cache, backend, expire,
- kconf->cache.max_elements, kconf->cache.max_memory, kconf->cache.no_overwrite);
+ kconf->storage = rspamd_kv_storage_new (kconf->id,
+ kconf->name,
+ cache,
+ backend,
+ expire,
+ kconf->cache.max_elements,
+ kconf->cache.max_memory,
+ kconf->cache.no_overwrite);
}
/* XML parse callbacks */
/* Called for open tags <foo bar="baz"> */
-void kvstorage_xml_start_element (GMarkupParseContext *context,
- const gchar *element_name,
- const gchar **attribute_names,
- const gchar **attribute_values,
- gpointer user_data,
- GError **error)
+void
+kvstorage_xml_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error)
{
- struct kvstorage_config_parser *kv_parser = user_data;
+ struct kvstorage_config_parser *kv_parser = user_data;
switch (kv_parser->state) {
case KVSTORAGE_STATE_INIT:
if (kv_parser->pool != NULL) {
rspamd_mempool_delete (kv_parser->pool);
}
- kv_parser->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ kv_parser->pool =
+ rspamd_mempool_new (rspamd_mempool_suggest_size ());
/* Create new kvstorage_config */
- kv_parser->current_storage = g_malloc0 (sizeof (struct kvstorage_config));
+ kv_parser->current_storage =
+ g_malloc0 (sizeof (struct kvstorage_config));
kv_parser->current_storage->id = last_id++;
}
if (g_ascii_strcasecmp (element_name, "type") == 0) {
}
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
- element_name);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
+ element_name);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
}
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in backend definition",
- element_name);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in backend definition",
+ element_name);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
}
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in expire definition",
- element_name);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in expire definition",
+ element_name);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
}
-#define CHECK_TAG(s) \
-do { \
-if (g_ascii_strcasecmp (element_name, kv_parser->cur_elt) == 0) { \
- kv_parser->state = (s); \
-} \
-else { \
- if (*error == NULL) *error = g_error_new (xml_error_quark (), XML_UNMATCHED_TAG, "element %s is unexpected in this state, expected %s", element_name, kv_parser->cur_elt); \
- kv_parser->state = KVSTORAGE_STATE_ERROR; \
-} \
-} while (0)
+#define CHECK_TAG(s) \
+ do { \
+ if (g_ascii_strcasecmp (element_name, kv_parser->cur_elt) == 0) { \
+ kv_parser->state = (s); \
+ } \
+ else { \
+ if (*error == NULL) *error = g_error_new ( \
+ xml_error_quark (), XML_UNMATCHED_TAG, "element %s is unexpected in this state, expected %s", element_name, \
+ kv_parser->cur_elt); \
+ kv_parser->state = KVSTORAGE_STATE_ERROR; \
+ } \
+ } while (0)
/* Called for close tags </foo> */
-void kvstorage_xml_end_element (GMarkupParseContext *context,
- const gchar *element_name,
- gpointer user_data,
- GError **error)
+void
+kvstorage_xml_end_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data,
+ GError **error)
{
- struct kvstorage_config_parser *kv_parser = user_data;
+ struct kvstorage_config_parser *kv_parser = user_data;
switch (kv_parser->state) {
case KVSTORAGE_STATE_INIT:
return;
}
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "end element %s is unexpected, expected start element",
- element_name);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "end element %s is unexpected, expected start element",
+ element_name);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
break;
}
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
- element_name);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
+ element_name);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
}
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
- element_name);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
+ element_name);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
#undef CHECK_TAG
/* text is not nul-terminated */
-void kvstorage_xml_text (GMarkupParseContext *context,
- const gchar *text,
- gsize text_len,
- gpointer user_data,
- GError **error)
+void
+kvstorage_xml_text (GMarkupParseContext *context,
+ const gchar *text,
+ gsize text_len,
+ gpointer user_data,
+ GError **error)
{
- struct kvstorage_config_parser *kv_parser = user_data;
- gchar *err_str;
+ struct kvstorage_config_parser *kv_parser = user_data;
+ gchar *err_str;
/* Strip space symbols */
while (*text && g_ascii_isspace (*text)) {
- text ++;
+ text++;
}
if (*text == '\0') {
/* Skip empty text */
case KVSTORAGE_STATE_INIT:
case KVSTORAGE_STATE_PARAM:
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "text is unexpected, expected start element");
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT,
+ "text is unexpected, expected start element");
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
break;
kv_parser->current_storage->id = strtoul (text, &err_str, 10);
if ((gsize)(err_str - text) != text_len) {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid number: %*s", (int)text_len, text);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "invalid number: %*s",
+ (int)text_len, text);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
else {
- last_id ++;
+ last_id++;
last_id = MAX (kv_parser->current_storage->id, last_id);
}
break;
rspamd_strlcpy (kv_parser->current_storage->name, text, text_len + 1);
break;
case KVSTORAGE_STATE_CACHE_MAX_ELTS:
- kv_parser->current_storage->cache.max_elements = rspamd_config_parse_limit (text, text_len);
+ kv_parser->current_storage->cache.max_elements =
+ rspamd_config_parse_limit (text, text_len);
break;
case KVSTORAGE_STATE_CACHE_MAX_MEM:
- kv_parser->current_storage->cache.max_memory = rspamd_config_parse_limit (text, text_len);
+ kv_parser->current_storage->cache.max_memory =
+ rspamd_config_parse_limit (text, text_len);
break;
case KVSTORAGE_STATE_CACHE_NO_OVERWRITE:
- kv_parser->current_storage->cache.no_overwrite = rspamd_config_parse_flag (text);
+ kv_parser->current_storage->cache.no_overwrite =
+ rspamd_config_parse_flag (text);
break;
case KVSTORAGE_STATE_CACHE_TYPE:
- if (g_ascii_strncasecmp (text, "hash", MIN (text_len, sizeof ("hash") - 1)) == 0) {
+ if (g_ascii_strncasecmp (text, "hash",
+ MIN (text_len, sizeof ("hash") - 1)) == 0) {
kv_parser->current_storage->cache.type = KVSTORAGE_TYPE_CACHE_HASH;
}
- else if (g_ascii_strncasecmp (text, "radix", MIN (text_len, sizeof ("radix") - 1)) == 0) {
+ else if (g_ascii_strncasecmp (text, "radix",
+ MIN (text_len, sizeof ("radix") - 1)) == 0) {
kv_parser->current_storage->cache.type = KVSTORAGE_TYPE_CACHE_RADIX;
}
#ifdef WITH_JUDY
- else if (g_ascii_strncasecmp (text, "judy", MIN (text_len, sizeof ("judy") - 1)) == 0) {
+ else if (g_ascii_strncasecmp (text, "judy",
+ MIN (text_len, sizeof ("judy") - 1)) == 0) {
kv_parser->current_storage->cache.type = KVSTORAGE_TYPE_CACHE_JUDY;
}
#endif
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid cache type: %*s", (int)text_len, text);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "invalid cache type: %*s",
+ (int)text_len, text);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
break;
case KVSTORAGE_STATE_BACKEND_TYPE:
- if (g_ascii_strncasecmp (text, "null", MIN (text_len, sizeof ("null") - 1)) == 0) {
- kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_NULL;
+ if (g_ascii_strncasecmp (text, "null",
+ MIN (text_len, sizeof ("null") - 1)) == 0) {
+ kv_parser->current_storage->backend.type =
+ KVSTORAGE_TYPE_BACKEND_NULL;
}
- else if (g_ascii_strncasecmp (text, "file", MIN (text_len, sizeof ("file") - 1)) == 0) {
- kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_FILE;
+ else if (g_ascii_strncasecmp (text, "file",
+ MIN (text_len, sizeof ("file") - 1)) == 0) {
+ kv_parser->current_storage->backend.type =
+ KVSTORAGE_TYPE_BACKEND_FILE;
}
#ifdef WITH_DB
- else if (g_ascii_strncasecmp (text, "bdb", MIN (text_len, sizeof ("bdb") - 1)) == 0) {
- kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_BDB;
+ else if (g_ascii_strncasecmp (text, "bdb",
+ MIN (text_len, sizeof ("bdb") - 1)) == 0) {
+ kv_parser->current_storage->backend.type =
+ KVSTORAGE_TYPE_BACKEND_BDB;
}
#endif
#ifdef WITH_SQLITE
- else if (g_ascii_strncasecmp (text, "sqlite", MIN (text_len, sizeof ("sqlite") - 1)) == 0) {
- kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_SQLITE;
+ else if (g_ascii_strncasecmp (text, "sqlite",
+ MIN (text_len, sizeof ("sqlite") - 1)) == 0) {
+ kv_parser->current_storage->backend.type =
+ KVSTORAGE_TYPE_BACKEND_SQLITE;
}
#endif
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid backend type: %*s", (int)text_len, text);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "invalid backend type: %*s",
+ (int)text_len, text);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
break;
case KVSTORAGE_STATE_BACKEND_FILENAME:
kv_parser->current_storage->backend.filename = g_malloc (text_len + 1);
- rspamd_strlcpy (kv_parser->current_storage->backend.filename, text, text_len + 1);
+ rspamd_strlcpy (kv_parser->current_storage->backend.filename,
+ text,
+ text_len + 1);
break;
case KVSTORAGE_STATE_BACKEND_SYNC_OPS:
- kv_parser->current_storage->backend.sync_ops = rspamd_config_parse_limit (text, text_len);
+ kv_parser->current_storage->backend.sync_ops =
+ rspamd_config_parse_limit (text, text_len);
break;
case KVSTORAGE_STATE_BACKEND_DO_FSYNC:
- kv_parser->current_storage->backend.do_fsync = rspamd_config_parse_flag (text);
+ kv_parser->current_storage->backend.do_fsync =
+ rspamd_config_parse_flag (text);
break;
case KVSTORAGE_STATE_BACKEND_DO_REF:
- kv_parser->current_storage->backend.do_ref = rspamd_config_parse_flag (text);
+ kv_parser->current_storage->backend.do_ref = rspamd_config_parse_flag (
+ text);
break;
case KVSTORAGE_STATE_EXPIRE_TYPE:
- if (g_ascii_strncasecmp (text, "lru", MIN (text_len, sizeof ("lru") - 1)) == 0) {
+ if (g_ascii_strncasecmp (text, "lru",
+ MIN (text_len, sizeof ("lru") - 1)) == 0) {
kv_parser->current_storage->expire.type = KVSTORAGE_TYPE_EXPIRE_LRU;
}
else {
if (*error == NULL) {
- *error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid expire type: %*s", (int)text_len, text);
+ *error = g_error_new (
+ xml_error_quark (), XML_EXTRA_ELEMENT, "invalid expire type: %*s",
+ (int)text_len, text);
}
kv_parser->state = KVSTORAGE_STATE_ERROR;
}
}
/* Called on error, including one set by other
-* methods in the vtable. The GError should not be freed.
-*/
+ * methods in the vtable. The GError should not be freed.
+ */
void
-kvstorage_xml_error (GMarkupParseContext *context,
- GError *error,
- gpointer user_data)
+kvstorage_xml_error (GMarkupParseContext *context,
+ GError *error,
+ gpointer user_data)
{
msg_err ("kvstorage xml parser error: %s", error->message);
}
static void
kvstorage_cleanup (gpointer ud)
{
- struct kvstorage_config_parser *kv_parser = ud;
+ struct kvstorage_config_parser *kv_parser = ud;
- g_hash_table_insert (storages, &kv_parser->current_storage->id, kv_parser->current_storage);
+ g_hash_table_insert (storages,
+ &kv_parser->current_storage->id,
+ kv_parser->current_storage);
kv_parser->state = KVSTORAGE_STATE_INIT;
g_hash_table_foreach (storages, kvstorage_init_callback, NULL);
kv_parser->current_storage = NULL;
void
init_kvstorage_config (void)
{
- GMarkupParser *parser;
- struct kvstorage_config_parser *kv_parser;
+ GMarkupParser *parser;
+ struct kvstorage_config_parser *kv_parser;
if (storages == NULL) {
- storages = g_hash_table_new_full (g_int_hash, g_int_equal, NULL, kvstorage_config_destroy);
+ storages = g_hash_table_new_full (g_int_hash,
+ g_int_equal,
+ NULL,
+ kvstorage_config_destroy);
}
else {
/* Create new global table */
g_hash_table_destroy (storages);
- storages = g_hash_table_new_full (g_int_hash, g_int_equal, NULL, kvstorage_config_destroy);
+ storages = g_hash_table_new_full (g_int_hash,
+ g_int_equal,
+ NULL,
+ kvstorage_config_destroy);
}
/* Create and register subparser */
}
/* Get configuration for kvstorage with specified ID */
-struct kvstorage_config*
+struct kvstorage_config *
get_kvstorage_config (gint id)
{
if (storages == NULL) {
void init_kvstorage_config (void);
/* Get configuration for kvstorage with specified ID */
-struct kvstorage_config* get_kvstorage_config (gint id);
+struct kvstorage_config * get_kvstorage_config (gint id);
void destroy_kvstorage_config (void);
#include "config.h"
#include "kvstorage.h"
#include "kvstorage_file.h"
-#include "util.h"
#include "main.h"
+#include "util.h"
struct file_op {
struct rspamd_kv_element *elt;
/* Main file structure */
struct rspamd_file_backend {
- backend_init init_func; /*< this callback is called on kv storage initialization */
- backend_insert insert_func; /*< this callback is called when element is inserted */
- backend_replace replace_func; /*< this callback is called when element is replaced */
- backend_lookup lookup_func; /*< this callback is used for lookup of element */
- backend_delete delete_func; /*< this callback is called when an element is deleted */
- backend_sync sync_func; /*< this callback is called when backend need to be synced */
- backend_incref incref_func; /*< this callback is called when element must be ref'd */
- backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
+ backend_init init_func; /*< this callback is called on kv storage initialization */
+ backend_insert insert_func; /*< this callback is called when element is inserted */
+ backend_replace replace_func; /*< this callback is called when element is replaced */
+ backend_lookup lookup_func; /*< this callback is used for lookup of element */
+ backend_delete delete_func; /*< this callback is called when an element is deleted */
+ backend_sync sync_func; /*< this callback is called when backend need to be synced */
+ backend_incref incref_func; /*< this callback is called when element must be ref'd */
+ backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
gchar *filename;
gchar *dirname;
guint dirlen;
gboolean initialized;
};
-static const gchar hexdigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+static const gchar hexdigits[] =
+{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
+ 'f'};
/* Generate file name for operation */
static gboolean
-get_file_name (struct rspamd_file_backend *db, gchar *key, guint keylen, gchar *filebuf, guint buflen)
+get_file_name (struct rspamd_file_backend *db,
+ gchar *key,
+ guint keylen,
+ gchar *filebuf,
+ guint buflen)
{
- gchar *p = filebuf, *end = filebuf + buflen,
- *k = key, t;
- guint i;
+ gchar *p = filebuf, *end = filebuf + buflen,
+ *k = key, t;
+ guint i;
/* First copy backend dirname to file buf */
if (buflen <= db->dirlen) {
memcpy (p, db->dirname, db->dirlen);
p += db->dirlen;
*p++ = G_DIR_SEPARATOR;
- for (i = 0; i < MIN (keylen, db->levels); i ++) {
+ for (i = 0; i < MIN (keylen, db->levels); i++) {
if (p == end) {
/* Filebuf is not large enough */
return FALSE;
t = *k;
*p++ = hexdigits[(t & 0xf) ^ ((t & 0xf0) >> 4)];
*p++ = G_DIR_SEPARATOR;
- k ++;
+ k++;
}
/* Now we have directory, append base64 encoded filename */
k = key;
t = *k;
*p++ = hexdigits[(t >> 4) & 0xf];
*p++ = hexdigits[t & 0xf];
- k ++;
+ k++;
}
*p = '\0';
static guint32
file_get_ref (gint fd)
{
- guint32 target;
+ guint32 target;
if (read (fd, &target, sizeof (guint32)) != sizeof (guint32)) {
return 0;
static gint
file_open_fd (const gchar *path, gsize *len, gint flags)
{
- gint fd;
- struct stat st;
+ gint fd;
+ struct stat st;
if ((flags & O_CREAT) != 0) {
/* Open file */
- if ((fd = open (path, flags, S_IRUSR|S_IWUSR|S_IRGRP)) != -1) {
+ if ((fd = open (path, flags, S_IRUSR | S_IWUSR | S_IRGRP)) != -1) {
rspamd_fallocate (fd, 0, *len);
#ifdef HAVE_FADVISE
posix_fadvise (fd, 0, *len, POSIX_FADV_SEQUENTIAL);
/* Process single file operation */
static gboolean
-file_process_single_op (struct rspamd_file_backend *db, struct file_op *op, gint *pfd)
+file_process_single_op (struct rspamd_file_backend *db,
+ struct file_op *op,
+ gint *pfd)
{
- gchar filebuf[PATH_MAX];
- gint fd;
- gsize len;
- struct iovec iov[2];
- guint32 ref;
+ gchar filebuf[PATH_MAX];
+ gint fd;
+ gsize len;
+ struct iovec iov[2];
+ guint32 ref;
/* Get filename */
- if (!get_file_name (db, ELT_KEY (op->elt), op->elt->keylen, filebuf, sizeof (filebuf))) {
+ if (!get_file_name (db, ELT_KEY (op->elt), op->elt->keylen, filebuf,
+ sizeof (filebuf))) {
return FALSE;
}
else {
/* Decrease ref */
lseek (fd, 0, SEEK_SET);
- if (! file_set_ref (fd, --ref)) {
+ if (!file_set_ref (fd, --ref)) {
*pfd = fd;
return FALSE;
}
}
}
else {
- if ((fd = file_open_fd (filebuf, &len, O_CREAT|O_WRONLY|O_TRUNC)) == -1) {
+ if ((fd =
+ file_open_fd (filebuf, &len, O_CREAT | O_WRONLY | O_TRUNC)) == -1) {
*pfd = -1;
return FALSE;
}
static void
file_sync_fds (gint *fds, gint len, gboolean do_fsync)
{
- gint i, fd;
+ gint i, fd;
- for (i = 0; i < len; i ++) {
+ for (i = 0; i < len; i++) {
fd = fds[i];
if (fd != -1) {
if (do_fsync) {
static gboolean
file_process_queue (struct rspamd_kv_backend *backend)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- struct file_op *op;
- GList *cur;
- gint *fds, i = 0, len;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ struct file_op *op;
+ GList *cur;
+ gint *fds, i = 0, len;
len = g_queue_get_length (db->ops_queue);
if (len == 0) {
cur = db->ops_queue->head;
while (cur) {
op = cur->data;
- if (! file_process_single_op (db, op, &fds[i])) {
+ if (!file_process_single_op (db, op, &fds[i])) {
file_sync_fds (fds, i, db->do_fsync);
g_slice_free1 (len * sizeof (gint), fds);
return FALSE;
}
- i ++;
+ i++;
cur = g_list_next (cur);
}
cur = db->ops_queue->head;
while (cur) {
op = cur->data;
- if (op->op == FILE_OP_DELETE || ((op->elt->flags & KV_ELT_NEED_FREE) != 0 &&
- (op->elt->flags & KV_ELT_NEED_INSERT) == 0)) {
+ if (op->op == FILE_OP_DELETE ||
+ ((op->elt->flags & KV_ELT_NEED_FREE) != 0 &&
+ (op->elt->flags & KV_ELT_NEED_INSERT) == 0)) {
/* Also clean memory */
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
}
static gboolean
rspamd_recursive_mkdir (guint levels)
{
- guint i;
- gchar nbuf[5];
+ guint i;
+ gchar nbuf[5];
/* Create directories for backend */
if (levels > 0) {
/* Create 16 directories */
- for (i = 0; i < 16; i ++) {
+ for (i = 0; i < 16; i++) {
rspamd_snprintf (nbuf, sizeof (nbuf), "./%c", hexdigits[i]);
if (mkdir (nbuf, 0755) != 0 && errno != EEXIST) {
- msg_info ("cannot create directory %s: %s", nbuf, strerror (errno));
+ msg_info ("cannot create directory %s: %s", nbuf,
+ strerror (errno));
return FALSE;
}
else if (levels > 1) {
msg_err ("chdir to %s failed: %s", nbuf, strerror (errno));
return FALSE;
}
- if (! rspamd_recursive_mkdir (levels - 1)) {
+ if (!rspamd_recursive_mkdir (levels - 1)) {
return FALSE;
}
if (chdir ("../") == -1) {
static void
rspamd_file_init (struct rspamd_kv_backend *backend)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- gchar pathbuf[PATH_MAX];
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ gchar pathbuf[PATH_MAX];
/* Save current directory */
if (getcwd (pathbuf, sizeof (pathbuf) - 1) == NULL) {
}
static gboolean
-rspamd_file_insert (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_file_insert (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- struct file_op *op;
- struct rspamd_kv_element search_elt;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ struct file_op *op;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
/* We found another op with such key in this queue */
- if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
+ if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
+ 0) {
/* Also clean memory */
g_hash_table_steal (db->ops_hash, &search_elt);
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
}
op->op = FILE_OP_INSERT;
- op->ref ++;
+ op->ref++;
op->elt = elt;
elt->flags |= KV_ELT_DIRTY;
g_hash_table_insert (db->ops_hash, elt, op);
g_hash_table_insert (db->ops_hash, elt, op);
}
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
return file_process_queue (backend);
}
}
static gboolean
-rspamd_file_replace (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_file_replace (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- struct file_op *op;
- struct rspamd_kv_element search_elt;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ struct file_op *op;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
}
if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
/* We found another op with such key in this queue */
- if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
+ if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
+ 0) {
/* Also clean memory */
g_hash_table_steal (db->ops_hash, &search_elt);
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
g_hash_table_insert (db->ops_hash, elt, op);
}
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
return file_process_queue (backend);
}
return TRUE;
}
-static struct rspamd_kv_element*
-rspamd_file_lookup (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+static struct rspamd_kv_element *
+rspamd_file_lookup (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- struct file_op *op;
- struct rspamd_kv_element *elt = NULL;
- gchar filebuf[PATH_MAX];
- gint fd;
- struct rspamd_kv_element search_elt;
- gsize len;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ struct file_op *op;
+ struct rspamd_kv_element *elt = NULL;
+ gchar filebuf[PATH_MAX];
+ gint fd;
+ struct rspamd_kv_element search_elt;
+ gsize len;
search_elt.keylen = keylen;
search_elt.p = key;
close (fd);
- elt->flags &= ~(KV_ELT_DIRTY|KV_ELT_NEED_FREE);
+ elt->flags &= ~(KV_ELT_DIRTY | KV_ELT_NEED_FREE);
return elt;
}
static void
-rspamd_file_delete (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+rspamd_file_delete (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- gchar filebuf[PATH_MAX];
- struct rspamd_kv_element search_elt;
- struct file_op *op;
- gsize len;
- gint fd;
- guint32 ref;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ gchar filebuf[PATH_MAX];
+ struct rspamd_kv_element search_elt;
+ struct file_op *op;
+ gsize len;
+ gint fd;
+ guint32 ref;
if (!db->initialized) {
return;
if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
op->op = FILE_OP_DELETE;
if (op->ref > 0) {
- op->ref --;
+ op->ref--;
}
return;
}
}
static gboolean
-rspamd_file_incref (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+rspamd_file_incref (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
- gchar filebuf[PATH_MAX];
- struct rspamd_kv_element search_elt;
- struct file_op *op;
- gsize len;
- gint fd;
- guint32 ref;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ gchar filebuf[PATH_MAX];
+ struct rspamd_kv_element search_elt;
+ struct file_op *op;
+ gsize len;
+ gint fd;
+ guint32 ref;
if (!db->initialized) {
return FALSE;
search_elt.p = key;
/* First search in ops queue */
if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
- op->ref ++;
+ op->ref++;
if (op->op == FILE_OP_DELETE) {
op->op = FILE_OP_INSERT;
}
static void
rspamd_file_destroy (struct rspamd_kv_backend *backend)
{
- struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+ struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
if (db->initialized) {
file_process_queue (backend);
/* Create new file backend */
struct rspamd_kv_backend *
-rspamd_kv_file_new (const gchar *filename, guint sync_ops, guint levels, gboolean do_fsync, gboolean do_ref)
+rspamd_kv_file_new (const gchar *filename,
+ guint sync_ops,
+ guint levels,
+ gboolean do_fsync,
+ gboolean do_ref)
{
- struct rspamd_file_backend *new;
- struct stat st;
- gchar *dirname;
+ struct rspamd_file_backend *new;
+ struct stat st;
+ gchar *dirname;
if (filename == NULL) {
return NULL;
#include "kvstorage.h"
/* Create new file backend */
-struct rspamd_kv_backend* rspamd_kv_file_new (const gchar *filename, guint sync_ops,
- guint levels, gboolean do_fsync, gboolean do_ref);
+struct rspamd_kv_backend * rspamd_kv_file_new (const gchar *filename,
+ guint sync_ops,
+ guint levels,
+ gboolean do_fsync,
+ gboolean do_ref);
#endif /* KVSTORAGE_FILE_H_ */
*/
+#include "cfg_file.h"
+#include "cfg_xml.h"
#include "config.h"
#include "kvstorage.h"
#include "kvstorage_config.h"
#include "kvstorage_server.h"
-#include "cfg_file.h"
-#include "cfg_xml.h"
#include "main.h"
#define ERROR_COMMON "ERROR" CRLF
static sig_atomic_t soft_wanna_die = 0;
/* Logging functions */
-#define thr_err(...) do { \
- g_mutex_lock (thr->log_mtx); \
- rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_CRITICAL, __FUNCTION__, __VA_ARGS__); \
- g_mutex_unlock (thr->log_mtx); \
+#define thr_err(...) do { \
+ g_mutex_lock (thr->log_mtx); \
+ rspamd_common_log_function (rspamd_main->logger, \
+ G_LOG_LEVEL_CRITICAL, \
+ __FUNCTION__, \
+ __VA_ARGS__); \
+ g_mutex_unlock (thr->log_mtx); \
} while (0)
-#define thr_warn(...) do { \
- g_mutex_lock (thr->log_mtx); \
- rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_WARNING, __FUNCTION__, __VA_ARGS__); \
- g_mutex_unlock (thr->log_mtx); \
+#define thr_warn(...) do { \
+ g_mutex_lock (thr->log_mtx); \
+ rspamd_common_log_function (rspamd_main->logger, \
+ G_LOG_LEVEL_WARNING, \
+ __FUNCTION__, \
+ __VA_ARGS__); \
+ g_mutex_unlock (thr->log_mtx); \
} while (0)
-#define thr_info(...) do { \
- g_mutex_lock (thr->log_mtx); \
- rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_INFO, __FUNCTION__, __VA_ARGS__); \
- g_mutex_unlock (thr->log_mtx); \
+#define thr_info(...) do { \
+ g_mutex_lock (thr->log_mtx); \
+ rspamd_common_log_function (rspamd_main->logger, \
+ G_LOG_LEVEL_INFO, \
+ __FUNCTION__, \
+ __VA_ARGS__); \
+ g_mutex_unlock (thr->log_mtx); \
} while (0)
/* Init functions */
void start_keystorage (struct rspamd_worker *worker);
worker_t keystorage_worker = {
- "keystorage", /* Name */
- init_keystorage, /* Init function */
- start_keystorage, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- TRUE, /* Non threaded */
- FALSE, /* Non killable */
- SOCK_STREAM /* TCP socket */
+ "keystorage", /* Name */
+ init_keystorage, /* Init function */
+ start_keystorage, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ TRUE, /* Non threaded */
+ FALSE, /* Non killable */
+ SOCK_STREAM /* TCP socket */
};
#ifndef HAVE_SA_SIGINFO
gpointer
init_keystorage (void)
{
- struct kvstorage_worker_ctx *ctx;
- GQuark type;
+ struct kvstorage_worker_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("keystorage");
ctx = g_malloc0 (sizeof (struct kvstorage_worker_ctx));
ctx->timeout_raw = 300000;
register_worker_opt (type, "timeout", xml_handle_seconds, ctx,
- G_STRUCT_OFFSET (struct kvstorage_worker_ctx, timeout_raw));
+ G_STRUCT_OFFSET (struct kvstorage_worker_ctx, timeout_raw));
register_worker_opt (type, "redis", xml_handle_boolean, ctx,
- G_STRUCT_OFFSET (struct kvstorage_worker_ctx, is_redis));
+ G_STRUCT_OFFSET (struct kvstorage_worker_ctx, is_redis));
return ctx;
}
static gboolean
config_kvstorage_worker (struct rspamd_worker *worker)
{
- struct kvstorage_worker_ctx *ctx = worker->ctx;
+ struct kvstorage_worker_ctx *ctx = worker->ctx;
/* Init timeval */
msec_to_tv (ctx->timeout_raw, &ctx->io_timeout);
if (len == 3) {
/* Set or get command */
if ((c[0] == 'g' || c[0] == 'G') &&
- (c[1] == 'e' || c[1] == 'E') &&
- (c[2] == 't' || c[2] == 'T')) {
+ (c[1] == 'e' || c[1] == 'E') &&
+ (c[2] == 't' || c[2] == 'T')) {
session->command = KVSTORAGE_CMD_GET;
}
else if ((c[0] == 's' || c[0] == 'S') &&
- (c[1] == 'e' || c[1] == 'E') &&
- (c[2] == 't' || c[2] == 'T')) {
+ (c[1] == 'e' || c[1] == 'E') &&
+ (c[2] == 't' || c[2] == 'T')) {
session->command = KVSTORAGE_CMD_SET;
}
else if ((c[0] == 'd' || c[0] == 'D') &&
- (c[1] == 'e' || c[1] == 'E') &&
- (c[2] == 'l' || c[2] == 'L')) {
+ (c[1] == 'e' || c[1] == 'E') &&
+ (c[2] == 'l' || c[2] == 'L')) {
session->command = KVSTORAGE_CMD_DELETE;
}
else {
}
else if (len == 4) {
if ((c[0] == 'i' || c[0] == 'I') &&
- (c[1] == 'n' || c[1] == 'N') &&
- (c[2] == 'c' || c[2] == 'C') &&
- (c[3] == 'r' || c[3] == 'R')) {
+ (c[1] == 'n' || c[1] == 'N') &&
+ (c[2] == 'c' || c[2] == 'C') &&
+ (c[3] == 'r' || c[3] == 'R')) {
session->command = KVSTORAGE_CMD_INCR;
session->arg_data.value = 1;
}
else if ((c[0] == 'd' || c[0] == 'D') &&
- (c[1] == 'e' || c[1] == 'E') &&
- (c[2] == 'c' || c[2] == 'C') &&
- (c[3] == 'r' || c[3] == 'R')) {
+ (c[1] == 'e' || c[1] == 'E') &&
+ (c[2] == 'c' || c[2] == 'C') &&
+ (c[3] == 'r' || c[3] == 'R')) {
session->command = KVSTORAGE_CMD_DECR;
session->arg_data.value = -1;
}
else if (g_ascii_strncasecmp (c, "quit", 4) == 0) {
session->command = KVSTORAGE_CMD_QUIT;
}
- else if (g_ascii_strncasecmp (c, "sync", 4) == 0 || g_ascii_strncasecmp (c, "save", 4) == 0) {
+ else if (g_ascii_strncasecmp (c, "sync",
+ 4) == 0 || g_ascii_strncasecmp (c, "save", 4) == 0) {
session->command = KVSTORAGE_CMD_SYNC;
}
}
else if (len == 6) {
if ((c[0] == 'i' || c[0] == 'I') &&
- (c[1] == 'n' || c[1] == 'N') &&
- (c[2] == 'c' || c[2] == 'C') &&
- (c[3] == 'r' || c[3] == 'R') &&
- (c[4] == 'b' || c[4] == 'B') &&
- (c[5] == 'y' || c[5] == 'Y')) {
+ (c[1] == 'n' || c[1] == 'N') &&
+ (c[2] == 'c' || c[2] == 'C') &&
+ (c[3] == 'r' || c[3] == 'R') &&
+ (c[4] == 'b' || c[4] == 'B') &&
+ (c[5] == 'y' || c[5] == 'Y')) {
session->command = KVSTORAGE_CMD_INCR;
session->arg_data.value = 1;
}
else if ((c[0] == 'd' || c[0] == 'D') &&
- (c[1] == 'e' || c[1] == 'E') &&
- (c[2] == 'c' || c[2] == 'C') &&
- (c[3] == 'r' || c[3] == 'R') &&
- (c[4] == 'b' || c[4] == 'B') &&
- (c[5] == 'y' || c[5] == 'Y')) {
+ (c[1] == 'e' || c[1] == 'E') &&
+ (c[2] == 'c' || c[2] == 'C') &&
+ (c[3] == 'r' || c[3] == 'R') &&
+ (c[4] == 'b' || c[4] == 'B') &&
+ (c[5] == 'y' || c[5] == 'Y')) {
session->command = KVSTORAGE_CMD_DECR;
session->arg_data.value = -1;
}
else if ((c[0] == 'd' || c[0] == 'D') &&
- (c[1] == 'e' || c[1] == 'E') &&
- (c[2] == 'l' || c[2] == 'L') &&
- (c[3] == 'e' || c[3] == 'E') &&
- (c[4] == 't' || c[4] == 'T') &&
- (c[5] == 'e' || c[5] == 'E')) {
+ (c[1] == 'e' || c[1] == 'E') &&
+ (c[2] == 'l' || c[2] == 'L') &&
+ (c[3] == 'e' || c[3] == 'E') &&
+ (c[4] == 't' || c[4] == 'T') &&
+ (c[5] == 'e' || c[5] == 'E')) {
session->command = KVSTORAGE_CMD_DELETE;
}
else if (g_ascii_strncasecmp (c, "select", 6) == 0) {
static gboolean
parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
{
- gchar *p, *c, *end;
- gint state = 0, next_state = 0;
- gboolean is_redis;
+ gchar *p, *c, *end;
+ gint state = 0, next_state = 0;
+ gboolean is_redis;
p = in->begin;
end = in->begin + in->len;
case 0:
/* At this state we try to read identifier of storage */
if (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
else {
if (g_ascii_isspace (*p) && p != c) {
case 1:
/* At this state we parse command */
if (g_ascii_isalpha (*p) && p != end) {
- p ++;
+ p++;
}
else {
if (parse_kvstorage_command (session, c, p - c)) {
case 2:
/* Read and store key */
if (!g_ascii_isspace (*p) && end != p) {
- p ++;
+ p++;
}
else {
if (p == c) {
return FALSE;
}
else {
- session->key = rspamd_mempool_alloc (session->pool, p - c + 1);
+ session->key = rspamd_mempool_alloc (session->pool,
+ p - c + 1);
rspamd_strlcpy (session->key, c, p - c + 1);
session->keylen = p - c;
/* Now we must select next state based on command */
if (session->command == KVSTORAGE_CMD_SET ||
- session->command == KVSTORAGE_CMD_INCR ||
- session->command == KVSTORAGE_CMD_DECR) {
+ session->command == KVSTORAGE_CMD_INCR ||
+ session->command == KVSTORAGE_CMD_DECR) {
/* Read flags */
state = 99;
if (is_redis) {
case 3:
/* Read flags */
if (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
else {
if (g_ascii_isspace (*p)) {
case 4:
/* Read exptime */
if (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
else {
if (g_ascii_isspace (*p)) {
case 5:
/* Read size or incr/decr values */
if (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
else {
if (g_ascii_isspace (*p) || p >= end - 1) {
if (p != c) {
session->arg_data.value = strtoul (c, NULL, 10);
if (session->command == KVSTORAGE_CMD_DECR) {
- session->arg_data.value = -session->arg_data.value;
+ session->arg_data.value =
+ -session->arg_data.value;
}
}
else if (session->command == KVSTORAGE_CMD_INCR) {
case 6:
/* Read index of storage */
if (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
else {
if (g_ascii_isspace (*p) || end == p) {
case 7:
/* Read arguments count */
if (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
else {
if (g_ascii_isspace (*p) || end == p) {
case 99:
/* Skip spaces state */
if (g_ascii_isspace (*p)) {
- p ++;
+ p++;
}
else {
c = p;
static gboolean
kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
{
- gint r;
- gchar outbuf[BUFSIZ], intbuf[sizeof ("9223372036854775807")];
- gboolean res;
- struct rspamd_kv_element *elt;
- guint eltlen;
- glong longval;
+ gint r;
+ gchar outbuf[BUFSIZ], intbuf[sizeof ("9223372036854775807")];
+ gboolean res;
+ struct rspamd_kv_element *elt;
+ guint eltlen;
+ glong longval;
if (session->command == KVSTORAGE_CMD_SET) {
session->state = KVSTORAGE_STATE_READ_DATA;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_CHARACTER, session->arg_data.length);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_CHARACTER,
+ session->arg_data.length);
}
else if (session->command == KVSTORAGE_CMD_GET) {
- elt = rspamd_kv_storage_lookup (session->cf->storage, session->key, session->keylen, session->now);
+ elt = rspamd_kv_storage_lookup (session->cf->storage,
+ session->key,
+ session->keylen,
+ session->now);
if (elt == NULL) {
RW_R_UNLOCK (&session->cf->storage->rwlock);
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_NOT_FOUND,
- sizeof (ERROR_NOT_FOUND) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_NOT_FOUND,
+ sizeof (ERROR_NOT_FOUND) - 1,
+ FALSE,
+ TRUE);
}
else {
return rspamd_dispatcher_write (session->dispather, "$-1" CRLF,
- sizeof ("$-1" CRLF) - 1, FALSE, TRUE);
+ sizeof ("$-1" CRLF) - 1, FALSE, TRUE);
}
}
else {
if (elt->flags & KV_ELT_INTEGER) {
- eltlen = rspamd_snprintf (intbuf, sizeof (intbuf), "%l", ELT_LONG (elt));
+ eltlen = rspamd_snprintf (intbuf,
+ sizeof (intbuf),
+ "%l",
+ ELT_LONG (elt));
}
else {
}
if (!is_redis) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "VALUE %s %ud %ud" CRLF,
- ELT_KEY (elt), elt->flags, eltlen);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "VALUE %s %ud %ud" CRLF,
+ ELT_KEY (elt),
+ elt->flags,
+ eltlen);
}
else {
r = rspamd_snprintf (outbuf, sizeof (outbuf), "$%ud" CRLF,
eltlen);
}
if (!rspamd_dispatcher_write (session->dispather, outbuf,
- r, TRUE, FALSE)) {
+ r, TRUE, FALSE)) {
RW_R_UNLOCK (&session->cf->storage->rwlock);
return FALSE;
}
if (elt->flags & KV_ELT_INTEGER) {
- if (!rspamd_dispatcher_write (session->dispather, intbuf, eltlen, TRUE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispather, intbuf,
+ eltlen, TRUE, TRUE)) {
RW_R_UNLOCK (&session->cf->storage->rwlock);
return FALSE;
}
}
else {
- if (!rspamd_dispatcher_write (session->dispather, ELT_DATA(elt), eltlen, TRUE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispather,
+ ELT_DATA (elt), eltlen, TRUE, TRUE)) {
RW_R_UNLOCK (&session->cf->storage->rwlock);
return FALSE;
}
}
session->elt = elt;
if (!is_redis) {
- res = rspamd_dispatcher_write (session->dispather, CRLF "END" CRLF,
- sizeof (CRLF "END" CRLF) - 1, FALSE, TRUE);
+ res = rspamd_dispatcher_write (session->dispather,
+ CRLF "END" CRLF,
+ sizeof (CRLF "END" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
res = rspamd_dispatcher_write (session->dispather, CRLF,
}
}
else if (session->command == KVSTORAGE_CMD_DELETE) {
- elt = rspamd_kv_storage_delete (session->cf->storage, session->key, session->keylen);
+ elt = rspamd_kv_storage_delete (session->cf->storage,
+ session->key,
+ session->keylen);
if (elt != NULL) {
if ((elt->flags & KV_ELT_DIRTY) == 0) {
/* Free memory if backend has deleted this element */
g_slice_free1 (ELT_SIZE (elt), elt);
}
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, "DELETED" CRLF,
- sizeof ("DELETED" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "DELETED" CRLF,
+ sizeof ("DELETED" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
return rspamd_dispatcher_write (session->dispather, ":1" CRLF,
- sizeof (":1" CRLF) - 1, FALSE, TRUE);
+ sizeof (":1" CRLF) - 1, FALSE, TRUE);
}
}
else {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_NOT_FOUND,
- sizeof (ERROR_NOT_FOUND) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_NOT_FOUND,
+ sizeof (ERROR_NOT_FOUND) - 1,
+ FALSE,
+ TRUE);
}
else {
return rspamd_dispatcher_write (session->dispather, ":0" CRLF,
- sizeof (":0" CRLF) - 1, FALSE, TRUE);
+ sizeof (":0" CRLF) - 1, FALSE, TRUE);
}
}
}
- else if (session->command == KVSTORAGE_CMD_INCR || session->command == KVSTORAGE_CMD_DECR) {
+ else if (session->command == KVSTORAGE_CMD_INCR || session->command ==
+ KVSTORAGE_CMD_DECR) {
longval = session->arg_data.value;
- if (!rspamd_kv_storage_increment (session->cf->storage, session->key, session->keylen, &longval)) {
+ if (!rspamd_kv_storage_increment (session->cf->storage, session->key,
+ session->keylen, &longval)) {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_NOT_FOUND,
- sizeof (ERROR_NOT_FOUND) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_NOT_FOUND,
+ sizeof (ERROR_NOT_FOUND) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR not found" CRLF,
- sizeof ("-ERR not found" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR not found" CRLF,
+ sizeof ("-ERR not found" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
else {
longval);
}
if (!rspamd_dispatcher_write (session->dispather, outbuf,
- r, FALSE, FALSE)) {
+ r, FALSE, FALSE)) {
return FALSE;
}
}
}
else if (session->command == KVSTORAGE_CMD_SYNC) {
- if (session->cf->storage->backend == NULL || session->cf->storage->backend->sync_func == NULL) {
+ if (session->cf->storage->backend == NULL ||
+ session->cf->storage->backend->sync_func == NULL) {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_COMMON,
- sizeof (ERROR_COMMON) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_COMMON,
+ sizeof (ERROR_COMMON) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR unsupported" CRLF,
- sizeof ("-ERR unsupported" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR unsupported" CRLF,
+ sizeof ("-ERR unsupported" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
else {
- if (session->cf->storage->backend->sync_func (session->cf->storage->backend)) {
+ if (session->cf->storage->backend->sync_func (session->cf->storage->
+ backend)) {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, "SYNCED" CRLF,
- sizeof ("SYNCED" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "SYNCED" CRLF,
+ sizeof ("SYNCED" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
- sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "+OK" CRLF,
+ sizeof ("+OK" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
else {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, "NOT_SYNCED" CRLF,
- sizeof ("NOT_SYNCED" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "NOT_SYNCED" CRLF,
+ sizeof ("NOT_SYNCED" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR not synced" CRLF,
- sizeof ("-ERR not synced" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR not synced" CRLF,
+ sizeof ("-ERR not synced" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
}
else if (session->command == KVSTORAGE_CMD_SELECT) {
if (!is_redis) {
return rspamd_dispatcher_write (session->dispather, "SELECTED" CRLF,
- sizeof ("SELECTED" CRLF) - 1, FALSE, TRUE);
+ sizeof ("SELECTED" CRLF) - 1, FALSE, TRUE);
}
else {
return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
- sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+ sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
}
}
else if (session->command == KVSTORAGE_CMD_QUIT) {
static gboolean
kvstorage_read_arglen (f_str_t *in, guint *len)
{
- gchar *p = in->begin, *end = in->begin + in->len, *c;
- gint state = 0;
+ gchar *p = in->begin, *end = in->begin + in->len, *c;
+ gint state = 0;
c = p;
while (p < end) {
return FALSE;
}
else {
- p ++;
+ p++;
c = p;
state = 1;
}
break;
case 1:
if (g_ascii_isdigit (*p) && p != end - 1) {
- p ++;
+ p++;
}
else {
if (p != end - 1) {
static gboolean
kvstorage_read_socket (f_str_t * in, void *arg)
{
- struct kvstorage_session *session = (struct kvstorage_session *) arg;
- struct kvstorage_worker_thread *thr;
- gint r;
- guint arglen = 0;
- gchar outbuf[BUFSIZ];
- gboolean is_redis;
+ struct kvstorage_session *session = (struct kvstorage_session *) arg;
+ struct kvstorage_worker_thread *thr;
+ gint r;
+ guint arglen = 0;
+ gchar outbuf[BUFSIZ];
+ gboolean is_redis;
if (in->len == 0) {
/* Skip empty commands */
case KVSTORAGE_STATE_READ_CMD:
/* Update timestamp */
session->now = time (NULL);
- if (! parse_kvstorage_line (session, in)) {
+ if (!parse_kvstorage_line (session, in)) {
thr_info ("%ud: unknown command: %V", thr->id, in);
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_UNKNOWN_COMMAND,
- sizeof (ERROR_UNKNOWN_COMMAND) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_UNKNOWN_COMMAND,
+ sizeof (ERROR_UNKNOWN_COMMAND) - 1,
+ FALSE,
+ TRUE);
}
else {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR unknown command '%V'" CRLF, in);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "-ERR unknown command '%V'" CRLF,
+ in);
return rspamd_dispatcher_write (session->dispather, outbuf,
- r, FALSE, TRUE);
+ r, FALSE, TRUE);
}
}
else {
if (session->cf == NULL) {
thr_info ("%ud: bad keystorage: %ud", thr->id, session->id);
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_INVALID_KEYSTORAGE,
- sizeof (ERROR_INVALID_KEYSTORAGE) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_INVALID_KEYSTORAGE,
+ sizeof (ERROR_INVALID_KEYSTORAGE) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR unknown keystorage" CRLF,
- sizeof ("-ERR unknown keystorage" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR unknown keystorage" CRLF,
+ sizeof ("-ERR unknown keystorage" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
if (session->state != KVSTORAGE_STATE_READ_ARGLEN) {
}
break;
case KVSTORAGE_STATE_READ_ARGLEN:
- if (! kvstorage_read_arglen (in, &arglen)) {
+ if (!kvstorage_read_arglen (in, &arglen)) {
session->state = KVSTORAGE_STATE_READ_CMD;
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR unknown arglen '%V'" CRLF, in);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "-ERR unknown arglen '%V'" CRLF,
+ in);
return rspamd_dispatcher_write (session->dispather, outbuf,
- r, FALSE, TRUE);
+ r, FALSE, TRUE);
}
else {
session->state = KVSTORAGE_STATE_READ_ARG;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_CHARACTER, arglen);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_CHARACTER,
+ arglen);
}
break;
case KVSTORAGE_STATE_READ_ARG:
if (session->argnum == 0) {
/* Read command */
- if (! parse_kvstorage_command (session, in->begin, in->len)) {
+ if (!parse_kvstorage_command (session, in->begin, in->len)) {
session->state = KVSTORAGE_STATE_READ_CMD;
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR unknown command '%V'" CRLF, in);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "-ERR unknown command '%V'" CRLF,
+ in);
return rspamd_dispatcher_write (session->dispather, outbuf,
- r, FALSE, TRUE);
+ r, FALSE, TRUE);
}
else {
- if (! kvstorage_check_argnum (session)) {
+ if (!kvstorage_check_argnum (session)) {
session->state = KVSTORAGE_STATE_READ_CMD;
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR invalid argnum for command '%V': %ud" CRLF,
- in, session->argc);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "-ERR invalid argnum for command '%V': %ud" CRLF,
+ in,
+ session->argc);
return rspamd_dispatcher_write (session->dispather, outbuf,
- r, FALSE, TRUE);
+ r, FALSE, TRUE);
}
else {
if (session->argnum == session->argc - 1) {
session->state = KVSTORAGE_STATE_READ_CMD;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
return kvstorage_process_command (session, TRUE);
}
else {
- session->argnum ++;
+ session->argnum++;
session->state = KVSTORAGE_STATE_READ_ARGLEN;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
}
}
}
session->keylen = in->len;
if (session->argnum == session->argc - 1) {
session->state = KVSTORAGE_STATE_READ_CMD;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
return kvstorage_process_command (session, TRUE);
}
else {
- session->argnum ++;
+ session->argnum++;
session->state = KVSTORAGE_STATE_READ_ARGLEN;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
}
}
else {
/* Special case for select command */
session->state = KVSTORAGE_STATE_READ_CMD;
- rspamd_strlcpy (outbuf, in->begin, MIN (sizeof (outbuf), in->len));
+ rspamd_strlcpy (outbuf, in->begin, MIN (sizeof (outbuf),
+ in->len));
session->id = strtoul (outbuf, NULL, 10);
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
return kvstorage_process_command (session, TRUE);
}
}
/* We get datablock for set command */
if (session->command == KVSTORAGE_CMD_SET && session->argc == 3) {
session->state = KVSTORAGE_STATE_READ_CMD;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
- if (rspamd_kv_storage_insert (session->cf->storage, session->key, session->keylen,
- in->begin, in->len,
- session->flags, session->expire)) {
- return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
- sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
+ if (rspamd_kv_storage_insert (session->cf->storage,
+ session->key, session->keylen,
+ in->begin, in->len,
+ session->flags, session->expire)) {
+ return rspamd_dispatcher_write (session->dispather,
+ "+OK" CRLF,
+ sizeof ("+OK" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR not stored" CRLF,
- sizeof ("-ERR not stored" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR not stored" CRLF,
+ sizeof ("-ERR not stored" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
- else if (session->command == KVSTORAGE_CMD_SET && session->argc == 4) {
+ else if (session->command == KVSTORAGE_CMD_SET && session->argc ==
+ 4) {
/* It is expire argument */
session->state = KVSTORAGE_STATE_READ_CMD;
rspamd_strtol (in->begin, in->len, (glong *)&session->expire);
- session->argnum ++;
+ session->argnum++;
session->state = KVSTORAGE_STATE_READ_ARGLEN;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
}
else {
session->state = KVSTORAGE_STATE_READ_CMD;
if (session->command == KVSTORAGE_CMD_DECR) {
session->arg_data.value = -session->arg_data.value;
}
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
return kvstorage_process_command (session, TRUE);
}
}
/* We get datablock for set command */
if (session->command == KVSTORAGE_CMD_SET && session->argc == 4) {
session->state = KVSTORAGE_STATE_READ_CMD;
- rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
- if (rspamd_kv_storage_insert (session->cf->storage, session->key, session->keylen,
- in->begin, in->len,
- session->flags, session->expire)) {
- return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
- sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+ rspamd_set_dispatcher_policy (session->dispather,
+ BUFFER_LINE,
+ -1);
+ if (rspamd_kv_storage_insert (session->cf->storage,
+ session->key, session->keylen,
+ in->begin, in->len,
+ session->flags, session->expire)) {
+ return rspamd_dispatcher_write (session->dispather,
+ "+OK" CRLF,
+ sizeof ("+OK" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR not stored" CRLF,
- sizeof ("-ERR not stored" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR not stored" CRLF,
+ sizeof ("-ERR not stored" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
}
case KVSTORAGE_STATE_READ_DATA:
session->state = KVSTORAGE_STATE_READ_CMD;
rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
- if (rspamd_kv_storage_insert (session->cf->storage, session->key, session->keylen,
- in->begin, in->len,
- session->flags, session->expire)) {
+ if (rspamd_kv_storage_insert (session->cf->storage, session->key,
+ session->keylen,
+ in->begin, in->len,
+ session->flags, session->expire)) {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, "STORED" CRLF,
- sizeof ("STORED" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "STORED" CRLF,
+ sizeof ("STORED" CRLF) - 1,
+ FALSE,
+ TRUE);
}
else {
return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
- sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+ sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
}
}
else {
if (!is_redis) {
- return rspamd_dispatcher_write (session->dispather, ERROR_NOT_STORED,
- sizeof (ERROR_NOT_STORED) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ ERROR_NOT_STORED,
+ sizeof (ERROR_NOT_STORED) - 1,
+ FALSE,
+ TRUE);
}
else {
- return rspamd_dispatcher_write (session->dispather, "-ERR not stored" CRLF,
- sizeof ("-ERR not stored" CRLF) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispather,
+ "-ERR not stored" CRLF,
+ sizeof ("-ERR not stored" CRLF) - 1,
+ FALSE,
+ TRUE);
}
}
static gboolean
kvstorage_write_socket (void *arg)
{
- struct kvstorage_session *session = (struct kvstorage_session *) arg;
+ struct kvstorage_session *session = (struct kvstorage_session *) arg;
if (session->elt) {
if ((session->elt->flags & KV_ELT_NEED_INSERT) != 0) {
/* Insert to cache and free element */
session->elt->flags &= ~KV_ELT_NEED_INSERT;
RW_R_UNLOCK (&session->cf->storage->rwlock);
- rspamd_kv_storage_insert_cache (session->cf->storage, ELT_KEY (session->elt),
- session->elt->keylen, ELT_DATA (session->elt),
- session->elt->size, session->elt->flags,
- session->elt->expire, NULL);
+ rspamd_kv_storage_insert_cache (session->cf->storage,
+ ELT_KEY (session->elt),
+ session->elt->keylen, ELT_DATA (session->elt),
+ session->elt->size, session->elt->flags,
+ session->elt->expire, NULL);
g_free (session->elt);
session->elt = NULL;
return TRUE;
static void
kvstorage_err_socket (GError * err, void *arg)
{
- struct kvstorage_session *session = (struct kvstorage_session *) arg;
- struct kvstorage_worker_thread *thr;
+ struct kvstorage_session *session = (struct kvstorage_session *) arg;
+ struct kvstorage_worker_thread *thr;
thr = session->thr;
if (err->code != -1) {
static void
thr_accept_socket (gint fd, short what, void *arg)
{
- struct kvstorage_worker_thread *thr = (struct kvstorage_worker_thread *)arg;
- union sa_union su;
- socklen_t addrlen = sizeof (su.ss);
- gint nfd;
- struct kvstorage_session *session;
+ struct kvstorage_worker_thread *thr = (struct kvstorage_worker_thread *)arg;
+ union sa_union su;
+ socklen_t addrlen = sizeof (su.ss);
+ gint nfd;
+ struct kvstorage_session *session;
g_mutex_lock (thr->accept_mtx);
- if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
+ if ((nfd =
+ accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
thr_warn ("%ud: accept failed: %s", thr->id, strerror (errno));
g_mutex_unlock (thr->accept_mtx);
return;
session->state = KVSTORAGE_STATE_READ_CMD;
session->thr = thr;
session->sock = nfd;
- session->dispather = rspamd_create_dispatcher (thr->ev_base, nfd, BUFFER_LINE,
- kvstorage_read_socket, kvstorage_write_socket,
- kvstorage_err_socket, thr->tv, session);
+ session->dispather = rspamd_create_dispatcher (thr->ev_base,
+ nfd,
+ BUFFER_LINE,
+ kvstorage_read_socket,
+ kvstorage_write_socket,
+ kvstorage_err_socket,
+ thr->tv,
+ session);
g_mutex_unlock (thr->accept_mtx);
session->elt = NULL;
}
else if (su.ss.ss_family == AF_INET) {
memcpy (&session->client_addr, &su.s4.sin_addr,
- sizeof (struct in_addr));
+ sizeof (struct in_addr));
}
}
static void
thr_term_socket (gint fd, short what, void *arg)
{
- struct kvstorage_worker_thread *thr = (struct kvstorage_worker_thread *)arg;
- struct timeval tv;
+ struct kvstorage_worker_thread *thr = (struct kvstorage_worker_thread *)arg;
+ struct timeval tv;
if (read (fd, &tv, sizeof (struct timeval)) != sizeof (struct timeval)) {
thr_err ("cannot read data from socket: %s", strerror (errno));
static gpointer
kvstorage_thread (gpointer ud)
{
- struct kvstorage_worker_thread *thr = ud;
+ struct kvstorage_worker_thread *thr = ud;
/* Block signals as it is dispatcher deity */
sigprocmask (SIG_BLOCK, thr->signals, NULL);
/* Init thread specific events */
thr->ev_base = event_init ();
- event_set (&thr->bind_ev, thr->worker->cf->listen_sock, EV_READ | EV_PERSIST, thr_accept_socket, (void *)thr);
+ event_set (&thr->bind_ev,
+ thr->worker->cf->listen_sock,
+ EV_READ | EV_PERSIST,
+ thr_accept_socket,
+ (void *)thr);
event_base_set (thr->ev_base, &thr->bind_ev);
event_add (&thr->bind_ev, NULL);
- event_set (&thr->term_ev, thr->term_sock[0], EV_READ | EV_PERSIST, thr_term_socket, (void *)thr);
+ event_set (&thr->term_ev,
+ thr->term_sock[0],
+ EV_READ | EV_PERSIST,
+ thr_term_socket,
+ (void *)thr);
event_base_set (thr->ev_base, &thr->term_ev);
event_add (&thr->term_ev, NULL);
* Create new thread, set it detached
*/
static struct kvstorage_worker_thread *
-create_kvstorage_thread (struct rspamd_worker *worker, struct kvstorage_worker_ctx *ctx, guint id, sigset_t *signals)
+create_kvstorage_thread (struct rspamd_worker *worker,
+ struct kvstorage_worker_ctx *ctx,
+ guint id,
+ sigset_t *signals)
{
- struct kvstorage_worker_thread *new;
- GError *err = NULL;
+ struct kvstorage_worker_thread *new;
+ GError *err = NULL;
- new = rspamd_mempool_alloc (ctx->pool, sizeof (struct kvstorage_worker_thread));
+ new =
+ rspamd_mempool_alloc (ctx->pool,
+ sizeof (struct kvstorage_worker_thread));
new->ctx = ctx;
new->worker = worker;
new->tv = &ctx->io_timeout;
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
new->thr = g_thread_create (kvstorage_thread, new, FALSE, &err);
#else
- gchar *name;
+ gchar *name;
- name = rspamd_mempool_alloc (ctx->pool, sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1);
- rspamd_snprintf (name, sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1, "kvstorage_thread%d", id);
+ name = rspamd_mempool_alloc (ctx->pool,
+ sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1);
+ rspamd_snprintf (name,
+ sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1,
+ "kvstorage_thread%d",
+ id);
new->thr = g_thread_new (name, kvstorage_thread, new);
#endif
void
start_keystorage (struct rspamd_worker *worker)
{
- struct sigaction signals;
- struct kvstorage_worker_ctx *ctx = worker->ctx;
- guint i;
- struct kvstorage_worker_thread *thr;
- struct timeval tv;
- GList *cur;
+ struct sigaction signals;
+ struct kvstorage_worker_ctx *ctx = worker->ctx;
+ guint i;
+ struct kvstorage_worker_thread *thr;
+ struct timeval tv;
+ GList *cur;
gperf_profiler_init (worker->srv->cfg, "kvstorage");
if (!g_thread_supported ()) {
- msg_err ("threads support is not supported on your system so kvstorage is not functionable");
+ msg_err (
+ "threads support is not supported on your system so kvstorage is not functionable");
exit (EXIT_SUCCESS);
}
/* Create socketpair */
#if _EVENT_NUMERIC_VERSION > 0x02000000
if (evthread_use_pthreads () == -1) {
- msg_err ("threads support is not supported in your libevent so kvstorage is not functionable");
+ msg_err (
+ "threads support is not supported in your libevent so kvstorage is not functionable");
exit (EXIT_SUCCESS);
}
#endif
#endif
/* Start workers threads */
- for (i = 0; i < worker->cf->count; i ++) {
+ for (i = 0; i < worker->cf->count; i++) {
thr = create_kvstorage_thread (worker, ctx, i, &signals.sa_mask);
if (thr != NULL) {
ctx->threads = g_list_prepend (ctx->threads, thr);
sigprocmask (SIG_BLOCK, &signals.sa_mask, NULL);
/* Signal processing cycle */
- for (;;) {
+ for (;; ) {
msg_debug ("calling sigsuspend");
sigemptyset (&signals.sa_mask);
sigsuspend (&signals.sa_mask);
cur = ctx->threads;
while (cur) {
thr = cur->data;
- while (write (thr->term_sock[1], &tv, sizeof (struct timeval)) == -1) {
+ while (write (thr->term_sock[1], &tv,
+ sizeof (struct timeval)) == -1) {
if (errno != EAGAIN) {
- msg_err ("write to term socket failed: %s", strerror (errno));
+ msg_err ("write to term socket failed: %s",
+ strerror (errno));
abort ();
}
}
soft_wanna_die = 0;
tv.tv_sec = SOFT_SHUTDOWN_TIME;
tv.tv_usec = 0;
- msg_info ("worker's shutdown is pending in %d sec", SOFT_SHUTDOWN_TIME);
+ msg_info ("worker's shutdown is pending in %d sec",
+ SOFT_SHUTDOWN_TIME);
cur = ctx->threads;
while (cur) {
thr = cur->data;
- while (write (thr->term_sock[1], &tv, sizeof (struct timeval)) == -1) {
+ while (write (thr->term_sock[1], &tv,
+ sizeof (struct timeval)) == -1) {
if (errno != EAGAIN) {
- msg_err ("write to term socket failed: %s", strerror (errno));
+ msg_err ("write to term socket failed: %s",
+ strerror (errno));
abort ();
}
}
#ifndef KVSTORAGE_SERVER_H_
#define KVSTORAGE_SERVER_H_
+#include "buffer.h"
#include "config.h"
#include "mem_pool.h"
-#include "buffer.h"
/* Configuration context for kvstorage worker */
struct kvstorage_worker_ctx {
#include "config.h"
#include "kvstorage.h"
#include "kvstorage_sqlite.h"
-#include "util.h"
#include "main.h"
+#include "util.h"
#include <sqlite3.h>
#define TABLE_NAME "kvstorage"
-#define CREATE_TABLE_SQL "CREATE TABLE " TABLE_NAME " (key TEXT CONSTRAINT _key PRIMARY KEY, data BLOB)"
-#define SET_SQL "INSERT OR REPLACE INTO " TABLE_NAME " (key, data) VALUES (?1, ?2)"
+#define CREATE_TABLE_SQL "CREATE TABLE " TABLE_NAME \
+ " (key TEXT CONSTRAINT _key PRIMARY KEY, data BLOB)"
+#define SET_SQL "INSERT OR REPLACE INTO " TABLE_NAME \
+ " (key, data) VALUES (?1, ?2)"
#define GET_SQL "SELECT data FROM " TABLE_NAME " WHERE key = ?1"
#define DELETE_SQL "DELETE FROM " TABLE_NAME " WHERE key = ?1"
/* Main sqlite structure */
struct rspamd_sqlite_backend {
- backend_init init_func; /*< this callback is called on kv storage initialization */
- backend_insert insert_func; /*< this callback is called when element is inserted */
- backend_replace replace_func; /*< this callback is called when element is replaced */
- backend_lookup lookup_func; /*< this callback is used for lookup of element */
- backend_delete delete_func; /*< this callback is called when an element is deleted */
- backend_sync sync_func; /*< this callback is called when backend need to be synced */
- backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
+ backend_init init_func; /*< this callback is called on kv storage initialization */
+ backend_insert insert_func; /*< this callback is called when element is inserted */
+ backend_replace replace_func; /*< this callback is called when element is replaced */
+ backend_lookup lookup_func; /*< this callback is used for lookup of element */
+ backend_delete delete_func; /*< this callback is called when an element is deleted */
+ backend_sync sync_func; /*< this callback is called when backend need to be synced */
+ backend_destroy destroy_func; /*< this callback is used for destroying all elements inside backend */
sqlite3 *dbp;
gchar *filename;
gchar *dirname;
/* Process single sqlite operation */
static gboolean
-sqlite_process_single_op (struct rspamd_sqlite_backend *db, struct sqlite_op *op)
+sqlite_process_single_op (struct rspamd_sqlite_backend *db,
+ struct sqlite_op *op)
{
- gboolean res = FALSE;
+ gboolean res = FALSE;
op->elt->flags &= ~KV_ELT_DIRTY;
switch (op->op) {
case SQLITE_OP_INSERT:
case SQLITE_OP_REPLACE:
- if (sqlite3_bind_text (db->set_stmt, 1, ELT_KEY (op->elt), op->elt->keylen, SQLITE_STATIC) == SQLITE_OK &&
- sqlite3_bind_blob (db->set_stmt, 2, op->elt, ELT_SIZE (op->elt), SQLITE_STATIC) == SQLITE_OK) {
+ if (sqlite3_bind_text (db->set_stmt, 1, ELT_KEY (op->elt),
+ op->elt->keylen, SQLITE_STATIC) == SQLITE_OK &&
+ sqlite3_bind_blob (db->set_stmt, 2, op->elt, ELT_SIZE (op->elt),
+ SQLITE_STATIC) == SQLITE_OK) {
if (sqlite3_step (db->set_stmt) == SQLITE_DONE) {
res = TRUE;
}
sqlite3_reset (db->set_stmt);
break;
case SQLITE_OP_DELETE:
- if (sqlite3_bind_text (db->delete_stmt, 1, ELT_KEY (op->elt), op->elt->keylen, SQLITE_STATIC) == SQLITE_OK) {
+ if (sqlite3_bind_text (db->delete_stmt, 1, ELT_KEY (op->elt),
+ op->elt->keylen, SQLITE_STATIC) == SQLITE_OK) {
if (sqlite3_step (db->delete_stmt) == SQLITE_DONE) {
res = TRUE;
}
static gboolean
sqlite_process_queue (struct rspamd_kv_backend *backend)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
- struct sqlite_op *op;
- GList *cur;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ struct sqlite_op *op;
+ GList *cur;
cur = db->ops_queue->head;
while (cur) {
op = cur->data;
- if (! sqlite_process_single_op (db, op)) {
+ if (!sqlite_process_single_op (db, op)) {
return FALSE;
}
cur = g_list_next (cur);
cur = db->ops_queue->head;
while (cur) {
op = cur->data;
- if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
+ if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
+ 0) {
/* Also clean memory */
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
}
static gboolean
rspamd_sqlite_create_table (struct rspamd_sqlite_backend *db)
{
- gint ret;
- sqlite3_stmt *stmt = NULL;
-
- ret = sqlite3_prepare_v2 (db->dbp, CREATE_TABLE_SQL, sizeof (CREATE_TABLE_SQL) - 1, &stmt, NULL);
+ gint ret;
+ sqlite3_stmt *stmt = NULL;
+
+ ret =
+ sqlite3_prepare_v2 (db->dbp,
+ CREATE_TABLE_SQL,
+ sizeof (CREATE_TABLE_SQL) - 1,
+ &stmt,
+ NULL);
if (ret != SQLITE_OK) {
if (stmt != NULL) {
sqlite3_finalize (stmt);
static void
rspamd_sqlite_init (struct rspamd_kv_backend *backend)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
- guint32 flags;
- gint ret, r;
- gchar sqlbuf[BUFSIZ];
- sqlite3_stmt *stmt = NULL;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ guint32 flags;
+ gint ret, r;
+ gchar sqlbuf[BUFSIZ];
+ sqlite3_stmt *stmt = NULL;
/* Set multi-threaded mode */
if (sqlite3_config (SQLITE_CONFIG_MULTITHREAD) != SQLITE_OK) {
}
flags = SQLITE_OPEN_READWRITE |
- SQLITE_OPEN_CREATE |
- SQLITE_OPEN_NOMUTEX;
+ SQLITE_OPEN_CREATE |
+ SQLITE_OPEN_NOMUTEX;
ret = sqlite3_open_v2 (db->filename, &db->dbp, flags, NULL);
goto err;
}
/* Now check if we have table */
- r = rspamd_snprintf (sqlbuf, sizeof (sqlbuf), "SELECT * FROM " TABLE_NAME " LIMIT 1");
+ r = rspamd_snprintf (sqlbuf,
+ sizeof (sqlbuf),
+ "SELECT * FROM " TABLE_NAME " LIMIT 1");
ret = sqlite3_prepare_v2 (db->dbp, sqlbuf, r, &stmt, NULL);
if (ret == SQLITE_ERROR) {
sqlite3_finalize (stmt);
/* Prepare required statements */
- ret = sqlite3_prepare_v2 (db->dbp, GET_SQL, sizeof (GET_SQL) - 1, &db->get_stmt, NULL);
+ ret = sqlite3_prepare_v2 (db->dbp,
+ GET_SQL,
+ sizeof (GET_SQL) - 1,
+ &db->get_stmt,
+ NULL);
if (ret != SQLITE_OK) {
goto err;
}
- ret = sqlite3_prepare_v2 (db->dbp, SET_SQL, sizeof (SET_SQL) - 1, &db->set_stmt, NULL);
+ ret = sqlite3_prepare_v2 (db->dbp,
+ SET_SQL,
+ sizeof (SET_SQL) - 1,
+ &db->set_stmt,
+ NULL);
if (ret != SQLITE_OK) {
goto err;
}
- ret = sqlite3_prepare_v2 (db->dbp, DELETE_SQL, sizeof (DELETE_SQL) - 1, &db->delete_stmt, NULL);
+ ret = sqlite3_prepare_v2 (db->dbp,
+ DELETE_SQL,
+ sizeof (DELETE_SQL) - 1,
+ &db->delete_stmt,
+ NULL);
if (ret != SQLITE_OK) {
goto err;
}
}
static gboolean
-rspamd_sqlite_insert (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_sqlite_insert (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
- struct sqlite_op *op;
- struct rspamd_kv_element search_elt;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ struct sqlite_op *op;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
/* We found another op with such key in this queue */
- if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
+ if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
+ 0) {
/* Also clean memory */
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
}
g_hash_table_insert (db->ops_hash, elt, op);
}
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
return sqlite_process_queue (backend);
}
}
static gboolean
-rspamd_sqlite_replace (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
+rspamd_sqlite_replace (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen,
+ struct rspamd_kv_element *elt)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
- struct sqlite_op *op;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ struct sqlite_op *op;
if (!db->initialized) {
return FALSE;
}
if ((op = g_hash_table_lookup (db->ops_hash, elt)) != NULL) {
/* We found another op with such key in this queue */
- if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
+ if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
+ 0) {
/* Also clean memory */
g_slice_free1 (ELT_SIZE (op->elt), op->elt);
}
g_hash_table_insert (db->ops_hash, elt, op);
}
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
return sqlite_process_queue (backend);
}
return TRUE;
}
-static struct rspamd_kv_element*
-rspamd_sqlite_lookup (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+static struct rspamd_kv_element *
+rspamd_sqlite_lookup (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
- struct sqlite_op *op;
- struct rspamd_kv_element *elt = NULL;
- gint l;
- gconstpointer d;
- struct rspamd_kv_element search_elt;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ struct sqlite_op *op;
+ struct rspamd_kv_element *elt = NULL;
+ gint l;
+ gconstpointer d;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
return op->elt;
}
- if (sqlite3_bind_text (db->get_stmt, 1, key, keylen, SQLITE_STATIC) == SQLITE_OK) {
+ if (sqlite3_bind_text (db->get_stmt, 1, key, keylen,
+ SQLITE_STATIC) == SQLITE_OK) {
if (sqlite3_step (db->get_stmt) == SQLITE_ROW) {
l = sqlite3_column_bytes (db->get_stmt, 0);
elt = g_malloc (l);
}
static void
-rspamd_sqlite_delete (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
+rspamd_sqlite_delete (struct rspamd_kv_backend *backend,
+ gpointer key,
+ guint keylen)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
- struct sqlite_op *op;
- struct rspamd_kv_element *elt;
- struct rspamd_kv_element search_elt;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ struct sqlite_op *op;
+ struct rspamd_kv_element *elt;
+ struct rspamd_kv_element search_elt;
search_elt.keylen = keylen;
search_elt.p = key;
g_queue_push_head (db->ops_queue, op);
g_hash_table_insert (db->ops_hash, elt, op);
- if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
+ if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
+ db->sync_ops) {
sqlite_process_queue (backend);
}
static void
rspamd_sqlite_destroy (struct rspamd_kv_backend *backend)
{
- struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+ struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
if (db->initialized) {
sqlite_process_queue (backend);
struct rspamd_kv_backend *
rspamd_kv_sqlite_new (const gchar *filename, guint sync_ops)
{
- struct rspamd_sqlite_backend *new;
- struct stat st;
- gchar *dirname;
+ struct rspamd_sqlite_backend *new;
+ struct stat st;
+ gchar *dirname;
if (filename == NULL) {
return NULL;
#ifdef WITH_SQLITE
/* Create new sqlite backend */
-struct rspamd_kv_backend* rspamd_kv_sqlite_new (const gchar *filename, guint sync_ops);
+struct rspamd_kv_backend * rspamd_kv_sqlite_new (const gchar *filename,
+ guint sync_ops);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "binlog.h"
+#include "cfg_file.h"
+#include "classifiers/classifiers.h"
#include "config.h"
-#include "util.h"
+#include "dns.h"
+#include "dynamic_cfg.h"
+#include "lua/lua_common.h"
#include "main.h"
+#include "map.h"
#include "message.h"
#include "protocol.h"
-#include "upstream.h"
-#include "cfg_file.h"
-#include "map.h"
-#include "dns.h"
-#include "tokenizers/tokenizers.h"
-#include "classifiers/classifiers.h"
-#include "binlog.h"
-#include "statfile_sync.h"
-#include "lua/lua_common.h"
-#include "dynamic_cfg.h"
#include "rrd.h"
+#include "statfile_sync.h"
+#include "tokenizers/tokenizers.h"
+#include "upstream.h"
+#include "util.h"
#define END "END" CRLF
void start_controller (struct rspamd_worker *worker);
worker_t controller_worker = {
- "controller", /* Name */
- init_controller, /* Init function */
- start_controller, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE, /* Killable */
- SOCK_STREAM /* TCP socket */
+ "controller", /* Name */
+ init_controller, /* Init function */
+ start_controller, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE, /* Killable */
+ SOCK_STREAM /* TCP socket */
};
enum command_type {
};
struct controller_command {
- gchar *command;
- gboolean privilleged;
- enum command_type type;
+ gchar *command;
+ gboolean privilleged;
+ enum command_type type;
};
struct custom_controller_command {
- const gchar *command;
- gboolean privilleged;
- gboolean require_message;
- controller_func_t handler;
+ const gchar *command;
+ gboolean privilleged;
+ gboolean require_message;
+ controller_func_t handler;
};
struct rspamd_controller_ctx {
- char *password;
- guint32 timeout;
- struct rspamd_dns_resolver *resolver;
- struct event_base *ev_base;
- struct event rrd_event;
- struct rspamd_rrd_file *rrd_file;
- struct rspamd_main *srv;
+ char *password;
+ guint32 timeout;
+ struct rspamd_dns_resolver *resolver;
+ struct event_base *ev_base;
+ struct event rrd_event;
+ struct rspamd_rrd_file *rrd_file;
+ struct rspamd_main *srv;
};
static struct controller_command commands[] = {
{"add_action", TRUE, COMMAND_ADD_ACTION}
};
-static GList *custom_commands = NULL;
+static GList *custom_commands = NULL;
-static time_t start_time;
+static time_t start_time;
-static gchar greetingbuf[1024];
+static gchar greetingbuf[1024];
-static gboolean controller_write_socket (void *arg);
+static gboolean controller_write_socket (void *arg);
static void
free_session (void *ud)
{
- GList *part;
- struct mime_part *p;
- struct controller_session *session = ud;
+ GList *part;
+ struct mime_part *p;
+ struct controller_session *session = ud;
msg_debug ("freeing session %p", session);
static gboolean
restful_write_reply (gint error_code, const gchar *err_message,
- const gchar *buf, gsize buflen, rspamd_io_dispatcher_t *d)
+ const gchar *buf, gsize buflen, rspamd_io_dispatcher_t *d)
{
- static gchar hbuf[256];
- gint r;
+ static gchar hbuf[256];
+ gint r;
r = rspamd_snprintf (hbuf, sizeof (hbuf),
"HTTP/1.0 %d %s" CRLF "Version: " RVERSION CRLF,
error_code, err_message ? err_message : "OK");
if (buflen > 0) {
- r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, "Content-Length: %z" CRLF, buflen);
+ r += rspamd_snprintf (hbuf + r,
+ sizeof (hbuf) - r,
+ "Content-Length: %z" CRLF,
+ buflen);
}
r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, CRLF);
static gboolean
restful_write_reply_string (gint error_code, const gchar *err_message,
- GString *buf, rspamd_io_dispatcher_t *d)
+ GString *buf, rspamd_io_dispatcher_t *d)
{
- static gchar hbuf[256];
- gint r;
+ static gchar hbuf[256];
+ gint r;
r = rspamd_snprintf (hbuf, sizeof (hbuf),
"HTTP/1.0 %d %s" CRLF "Version: " RVERSION CRLF,
error_code, err_message ? err_message : "OK");
if (buf->len > 0) {
- r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, "Content-Length: %z" CRLF, buf->len);
+ r += rspamd_snprintf (hbuf + r,
+ sizeof (hbuf) - r,
+ "Content-Length: %z" CRLF,
+ buf->len);
}
r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, CRLF);
static gint
check_auth (struct controller_command *cmd, struct controller_session *session)
{
- gchar out_buf[128];
- gint r;
+ gchar out_buf[128];
+ gint r;
if (cmd->privilleged && !session->authorized) {
if (!session->restful) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "not authorized" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "not authorized" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return 0;
}
}
else {
- (void)restful_write_reply (403, "Not authorized", NULL, 0, session->dispatcher);
+ (void)restful_write_reply (403,
+ "Not authorized",
+ NULL,
+ 0,
+ session->dispatcher);
}
return 0;
}
}
static gboolean
-write_whole_statfile (struct controller_session *session, gchar *symbol, struct rspamd_classifier_config *ccf)
+write_whole_statfile (struct controller_session *session,
+ gchar *symbol,
+ struct rspamd_classifier_config *ccf)
{
- stat_file_t *statfile;
- struct rspamd_statfile_config *st;
- gchar out_buf[BUFSIZ];
- guint i;
- guint64 rev, ti, len, pos, blocks;
- gchar *out;
- struct rspamd_binlog_element log_elt;
- struct stat_file_block *stat_elt;
+ stat_file_t *statfile;
+ struct rspamd_statfile_config *st;
+ gchar out_buf[BUFSIZ];
+ guint i;
+ guint64 rev, ti, len, pos, blocks;
+ gchar *out;
+ struct rspamd_binlog_element log_elt;
+ struct stat_file_block *stat_elt;
statfile = get_statfile_by_symbol (session->worker->srv->statfile_pool, ccf,
- symbol, &st, FALSE);
+ symbol, &st, FALSE);
if (statfile == NULL) {
return FALSE;
}
ti = time (NULL);
statfile_set_revision (statfile, rev, ti);
}
- msg_info ("send a whole statfile %s with version %uL to slave", symbol, rev);
+ msg_info ("send a whole statfile %s with version %uL to slave", symbol,
+ rev);
blocks = statfile_get_total_blocks (statfile);
len = blocks * sizeof (struct rspamd_binlog_element);
out = rspamd_mempool_alloc (session->session_pool, len);
- for (i = 0, pos = 0; i < blocks; i ++) {
- stat_elt = (struct stat_file_block *)((u_char *)statfile->map + statfile->seek_pos + i * sizeof (struct stat_file_block));
+ for (i = 0, pos = 0; i < blocks; i++) {
+ stat_elt =
+ (struct stat_file_block *)((u_char *)statfile->map +
+ statfile->seek_pos + i * sizeof (struct stat_file_block));
if (fabs (stat_elt->value) > 0.001) {
/* Write only those values which value is not 0 */
log_elt.h1 = stat_elt->hash1;
}
}
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "%uL %uL %uL" CRLF, rev, ti, pos);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, i, TRUE, FALSE)) {
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "%uL %uL %uL" CRLF,
+ rev,
+ ti,
+ pos);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, TRUE,
+ FALSE)) {
return FALSE;
}
if (!rspamd_dispatcher_write (session->dispatcher, out, pos, TRUE, TRUE)) {
return FALSE;
}
-
+
return TRUE;
}
static gboolean
process_sync_command (struct controller_session *session, gchar **args)
{
- gchar out_buf[BUFSIZ], *arg, *err_str, *symbol;
- gint r;
- guint64 rev, time;
- struct rspamd_statfile_config *st = NULL;
- struct rspamd_classifier_config *ccf;
- GList *cur;
- struct rspamd_binlog *binlog;
- GByteArray *data = NULL;
+ gchar out_buf[BUFSIZ], *arg, *err_str, *symbol;
+ gint r;
+ guint64 rev, time;
+ struct rspamd_statfile_config *st = NULL;
+ struct rspamd_classifier_config *ccf;
+ GList *cur;
+ struct rspamd_binlog *binlog;
+ GByteArray *data = NULL;
arg = *args;
if (!arg || *arg == '\0') {
msg_info ("bad symbol: %s", symbol);
return FALSE;
}
-
+
cur = g_list_first (ccf->statfiles);
while (cur) {
st = cur->data;
st = NULL;
cur = g_list_next (cur);
}
- if (st == NULL) {
+ if (st == NULL) {
msg_info ("bad symbol: %s", symbol);
- return FALSE;
- }
-
+ return FALSE;
+ }
+
binlog = get_binlog_by_statfile (st);
if (binlog == NULL) {
msg_info ("cannot open binlog: %s", symbol);
- return FALSE;
+ return FALSE;
}
-
+
while (binlog_sync (binlog, rev, &time, &data)) {
- rev ++;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "%uL %uL %z" CRLF, rev, time, data->len);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ rev++;
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "%uL %uL %z" CRLF,
+ rev,
+ time,
+ data->len);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE,
+ FALSE)) {
if (data != NULL) {
g_free (data);
}
return FALSE;
}
if (data->data != NULL) {
- if (!rspamd_dispatcher_write (session->dispatcher, data->data, data->len, TRUE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, data->data,
+ data->len, TRUE, FALSE)) {
if (data != NULL) {
g_free (data);
}
static gboolean
process_counters_command (struct controller_session *session)
{
- GList *cur;
- struct cache_item *item;
- struct symbols_cache *cache;
- GString *out;
+ GList *cur;
+ struct cache_item *item;
+ struct symbols_cache *cache;
+ GString *out;
cache = session->cfg->cache;
out = g_string_sized_new (BUFSIZ);
item = cur->data;
if (!item->is_callback) {
rspamd_printf_gstring (out, "%s %.2f %d %.3f" CRLF,
- item->s->symbol, item->s->weight,
- item->s->frequency, item->s->avg_time);
+ item->s->symbol, item->s->weight,
+ item->s->frequency, item->s->avg_time);
}
cur = g_list_next (cur);
}
item = cur->data;
if (!item->is_callback) {
rspamd_printf_gstring (out, "%s %.2f %d %.3f" CRLF,
- item->s->symbol, item->s->weight,
- item->s->frequency, item->s->avg_time);
+ item->s->symbol, item->s->weight,
+ item->s->frequency, item->s->avg_time);
}
cur = g_list_next (cur);
}
}
if (!session->restful) {
- return rspamd_dispatcher_write_string (session->dispatcher, out, FALSE, TRUE);
+ return rspamd_dispatcher_write_string (session->dispatcher,
+ out,
+ FALSE,
+ TRUE);
}
else {
return restful_write_reply_string (200, NULL, out, session->dispatcher);
static gboolean
process_stat_command (struct controller_session *session, gboolean do_reset)
{
- GString *out;
- gint i;
- guint64 used, total, rev, ham = 0, spam = 0;
- time_t ti;
- rspamd_mempool_stat_t mem_st;
- struct rspamd_classifier_config *ccf;
- stat_file_t *statfile;
- struct rspamd_statfile_config *st;
- GList *cur_cl, *cur_st;
- struct rspamd_stat *stat, stat_copy;
+ GString *out;
+ gint i;
+ guint64 used, total, rev, ham = 0, spam = 0;
+ time_t ti;
+ rspamd_mempool_stat_t mem_st;
+ struct rspamd_classifier_config *ccf;
+ stat_file_t *statfile;
+ struct rspamd_statfile_config *st;
+ GList *cur_cl, *cur_st;
+ struct rspamd_stat *stat, stat_copy;
rspamd_mempool_stat (&mem_st);
memcpy (&stat_copy, session->worker->srv->stat, sizeof (stat_copy));
stat = &stat_copy;
out = g_string_sized_new (BUFSIZ);
- rspamd_printf_gstring (out, "Messages scanned: %ud" CRLF, stat->messages_scanned);
+ rspamd_printf_gstring (out,
+ "Messages scanned: %ud" CRLF,
+ stat->messages_scanned);
if (stat->messages_scanned > 0) {
- for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i ++) {
- rspamd_printf_gstring (out, "Messages with action %s: %ud, %.2f%%" CRLF,
- str_action_metric (i), stat->actions_stat[i],
- (double)stat->actions_stat[i] / (double)stat->messages_scanned * 100.);
+ for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
+ rspamd_printf_gstring (out,
+ "Messages with action %s: %ud, %.2f%%" CRLF,
+ str_action_metric (
+ i),
+ stat->actions_stat[i],
+ (double)stat->actions_stat[i] / (double)stat->messages_scanned *
+ 100.);
if (i < METRIC_ACTION_GREYLIST) {
spam += stat->actions_stat[i];
}
session->worker->srv->stat->actions_stat[i] = 0;
}
}
- rspamd_printf_gstring (out, "Messages treated as spam: %ud, %.2f%%" CRLF, spam,
- (double)spam / (double)stat->messages_scanned * 100.);
- rspamd_printf_gstring (out, "Messages treated as ham: %ud, %.2f%%" CRLF, ham,
- (double)ham / (double)stat->messages_scanned * 100.);
- }
- rspamd_printf_gstring (out, "Messages learned: %ud" CRLF, stat->messages_learned);
- rspamd_printf_gstring (out, "Connections count: %ud" CRLF, stat->connections_count);
- rspamd_printf_gstring (out, "Control connections count: %ud" CRLF, stat->control_connections_count);
- rspamd_printf_gstring (out, "Pools allocated: %z" CRLF, mem_st.pools_allocated);
- rspamd_printf_gstring (out, "Pools freed: %z" CRLF, mem_st.pools_freed);
- rspamd_printf_gstring (out, "Bytes allocated: %z" CRLF, mem_st.bytes_allocated);
- rspamd_printf_gstring (out, "Memory chunks allocated: %z" CRLF, mem_st.chunks_allocated);
- rspamd_printf_gstring (out, "Shared chunks allocated: %z" CRLF, mem_st.shared_chunks_allocated);
- rspamd_printf_gstring (out, "Chunks freed: %z" CRLF, mem_st.chunks_freed);
- rspamd_printf_gstring (out, "Oversized chunks: %z" CRLF, mem_st.oversized_chunks);
- rspamd_printf_gstring (out, "Fuzzy hashes stored: %ud" CRLF, stat->fuzzy_hashes);
- rspamd_printf_gstring (out, "Fuzzy hashes expired: %ud" CRLF, stat->fuzzy_hashes_expired);
+ rspamd_printf_gstring (out,
+ "Messages treated as spam: %ud, %.2f%%" CRLF,
+ spam,
+ (double)spam / (double)stat->messages_scanned * 100.);
+ rspamd_printf_gstring (out,
+ "Messages treated as ham: %ud, %.2f%%" CRLF,
+ ham,
+ (double)ham / (double)stat->messages_scanned * 100.);
+ }
+ rspamd_printf_gstring (out,
+ "Messages learned: %ud" CRLF,
+ stat->messages_learned);
+ rspamd_printf_gstring (out,
+ "Connections count: %ud" CRLF,
+ stat->connections_count);
+ rspamd_printf_gstring (out,
+ "Control connections count: %ud" CRLF,
+ stat->control_connections_count);
+ rspamd_printf_gstring (out,
+ "Pools allocated: %z" CRLF,
+ mem_st.pools_allocated);
+ rspamd_printf_gstring (out,
+ "Pools freed: %z" CRLF,
+ mem_st.pools_freed);
+ rspamd_printf_gstring (out,
+ "Bytes allocated: %z" CRLF,
+ mem_st.bytes_allocated);
+ rspamd_printf_gstring (out,
+ "Memory chunks allocated: %z" CRLF,
+ mem_st.chunks_allocated);
+ rspamd_printf_gstring (out,
+ "Shared chunks allocated: %z" CRLF,
+ mem_st.shared_chunks_allocated);
+ rspamd_printf_gstring (out,
+ "Chunks freed: %z" CRLF,
+ mem_st.chunks_freed);
+ rspamd_printf_gstring (out,
+ "Oversized chunks: %z" CRLF,
+ mem_st.oversized_chunks);
+ rspamd_printf_gstring (out,
+ "Fuzzy hashes stored: %ud" CRLF,
+ stat->fuzzy_hashes);
+ rspamd_printf_gstring (out,
+ "Fuzzy hashes expired: %ud" CRLF,
+ stat->fuzzy_hashes_expired);
/* Now write statistics for each statfile */
cur_cl = g_list_first (session->cfg->classifiers);
while (cur_cl) {
cur_st = g_list_first (ccf->statfiles);
while (cur_st) {
st = cur_st->data;
- if ((statfile = statfile_pool_is_open (session->worker->srv->statfile_pool, st->path)) == NULL) {
- statfile = statfile_pool_open (session->worker->srv->statfile_pool, st->path, st->size, FALSE);
+ if ((statfile =
+ statfile_pool_is_open (session->worker->srv->statfile_pool,
+ st->path)) == NULL) {
+ statfile = statfile_pool_open (
+ session->worker->srv->statfile_pool,
+ st->path,
+ st->size,
+ FALSE);
}
if (statfile) {
used = statfile_get_used_blocks (statfile);
total = statfile_get_total_blocks (statfile);
statfile_get_revision (statfile, &rev, &ti);
- if (total != (guint64)-1 && used != (guint64)-1) {
+ if (total != (guint64) - 1 && used != (guint64) - 1) {
if (st->label) {
rspamd_printf_gstring (out,
- "Statfile: %s <%s> (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
- st->symbol, st->label, rev, st->size,
- (total - used), total,
- (double)((double)(total - used) / (double)total) * 100.);
+ "Statfile: %s <%s> (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
+ st->symbol,
+ st->label,
+ rev,
+ st->size,
+ (total - used),
+ total,
+ (double)((double)(total -
+ used) / (double)total) * 100.);
}
else {
rspamd_printf_gstring (out,
- "Statfile: %s (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
- st->symbol, rev, st->size,
- (total - used), total,
- (double)((double)(total - used) / (double)total) * 100.);
+ "Statfile: %s (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
+ st->symbol,
+ rev,
+ st->size,
+ (total - used),
+ total,
+ (double)((double)(total -
+ used) / (double)total) * 100.);
}
}
}
}
if (!session->restful) {
- return rspamd_dispatcher_write_string (session->dispatcher, out, FALSE, TRUE);
+ return rspamd_dispatcher_write_string (session->dispatcher,
+ out,
+ FALSE,
+ TRUE);
}
else {
return restful_write_reply_string (200, NULL, out, session->dispatcher);
}
static gboolean
-process_dynamic_conf_command (gchar **cmd_args, struct controller_session *session, gboolean is_action)
+process_dynamic_conf_command (gchar **cmd_args,
+ struct controller_session *session,
+ gboolean is_action)
{
- struct rspamd_config *cfg = session->cfg;
- gchar *arg, *metric, *name, *err_str;
- gdouble value;
- gboolean res;
- guint real_act;
+ struct rspamd_config *cfg = session->cfg;
+ gchar *arg, *metric, *name, *err_str;
+ gdouble value;
+ gboolean res;
+ guint real_act;
if (cfg->dynamic_conf == NULL) {
if (!session->restful) {
- return rspamd_dispatcher_write (session->dispatcher, "dynamic config is not specified" CRLF, 0, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispatcher,
+ "dynamic config is not specified" CRLF,
+ 0,
+ FALSE,
+ TRUE);
}
else {
- return restful_write_reply (500, "dynamic config is not specified", NULL, 0, session->dispatcher);
+ return restful_write_reply (500,
+ "dynamic config is not specified",
+ NULL,
+ 0,
+ session->dispatcher);
}
}
res = dump_dynamic_config (cfg);
if (res) {
if (!session->restful) {
- return rspamd_dispatcher_write (session->dispatcher, "OK" CRLF, 0, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispatcher,
+ "OK" CRLF,
+ 0,
+ FALSE,
+ TRUE);
}
else {
- return restful_write_reply (200, "OK", NULL, 0, session->dispatcher);
+ return restful_write_reply (200,
+ "OK",
+ NULL,
+ 0,
+ session->dispatcher);
}
}
else {
if (!session->restful) {
- return rspamd_dispatcher_write (session->dispatcher, "Error dumping dynamic config" CRLF, 0, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispatcher,
+ "Error dumping dynamic config" CRLF,
+ 0,
+ FALSE,
+ TRUE);
}
else {
- return restful_write_reply (500, "Error dumping dynamic config", NULL, 0, session->dispatcher);
+ return restful_write_reply (500,
+ "Error dumping dynamic config",
+ NULL,
+ 0,
+ session->dispatcher);
}
}
}
else {
if (!session->restful) {
- return rspamd_dispatcher_write (session->dispatcher, "Cannot add dynamic rule" CRLF, 0, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispatcher,
+ "Cannot add dynamic rule" CRLF,
+ 0,
+ FALSE,
+ TRUE);
}
else {
- return restful_write_reply (500, "Cannot add dynamic rule", NULL, 0, session->dispatcher);
+ return restful_write_reply (500,
+ "Cannot add dynamic rule",
+ NULL,
+ 0,
+ session->dispatcher);
}
}
invalid_arguments:
if (!session->restful) {
- return rspamd_dispatcher_write (session->dispatcher, "Invalid arguments" CRLF, 0, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->dispatcher,
+ "Invalid arguments" CRLF,
+ 0,
+ FALSE,
+ TRUE);
}
else {
- return restful_write_reply (500, "Invalid arguments", NULL, 0, session->dispatcher);
+ return restful_write_reply (500,
+ "Invalid arguments",
+ NULL,
+ 0,
+ session->dispatcher);
}
}
static gboolean
-process_command (struct controller_command *cmd, gchar **cmd_args, struct controller_session *session)
+process_command (struct controller_command *cmd,
+ gchar **cmd_args,
+ struct controller_session *session)
{
- gchar out_buf[BUFSIZ], *arg, *err_str;
- gint r = 0, days, hours, minutes;
- time_t uptime;
- guint32 size = 0;
- struct rspamd_classifier_config *cl;
- struct rspamd_controller_ctx *ctx = session->worker->ctx;
+ gchar out_buf[BUFSIZ], *arg, *err_str;
+ gint r = 0, days, hours, minutes;
+ time_t uptime;
+ guint32 size = 0;
+ struct rspamd_classifier_config *cl;
+ struct rspamd_controller_ctx *ctx = session->worker->ctx;
switch (cmd->type) {
case COMMAND_GET:
case COMMAND_POST:
session->restful = TRUE;
session->state = STATE_HEADER;
- session->kwargs = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+ session->kwargs = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
break;
case COMMAND_PASSWORD:
arg = *cmd_args;
if (!arg || *arg == '\0') {
msg_debug ("empty password passed");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "password command requires one argument" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "password command requires one argument" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
}
if (ctx->password == NULL) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "password command disabled in config, authorized access granted" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "password command disabled in config, authorized access granted" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
}
if (strncmp (arg, ctx->password, strlen (arg)) == 0) {
session->authorized = 1;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "password accepted" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "password accepted" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
session->authorized = 0;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "password NOT accepted" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "password NOT accepted" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
break;
case COMMAND_RELOAD:
if (check_auth (cmd, session)) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "reload request sent" CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "reload request sent" CRLF);
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (200, out_buf, NULL, 0, session->dispatcher)) {
+ if (!restful_write_reply (200, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
break;
case COMMAND_SHUTDOWN:
if (check_auth (cmd, session)) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "shutdown request sent" CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "shutdown request sent" CRLF);
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (200, out_buf, NULL, 0, session->dispatcher)) {
+ if (!restful_write_reply (200, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
days = uptime / 86400;
hours = uptime / 3600 - days * 24;
minutes = uptime / 60 - hours * 60 - days * 1440;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "%d day%s %d hour%s %d minute%s" CRLF, days, days > 1 ? "s" : " ", hours, hours > 1 ? "s" : " ", minutes, minutes > 1 ? "s" : " ");
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "%d day%s %d hour%s %d minute%s" CRLF,
+ days,
+ days > 1 ? "s" : " ",
+ hours,
+ hours > 1 ? "s" : " ",
+ minutes,
+ minutes > 1 ? "s" : " ");
}
/* If uptime is less than 1 minute print only seconds */
else if (uptime / 60 == 0) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "%d second%s" CRLF, (gint)uptime, (gint)uptime > 1 ? "s" : " ");
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "%d second%s" CRLF,
+ (gint)uptime,
+ (gint)uptime > 1 ? "s" : " ");
}
/* Else print the minutes and seconds. */
else {
hours = uptime / 3600;
minutes = uptime / 60 - hours * 60;
uptime -= hours * 3600 + minutes * 60;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "%d hour%s %d minute%s %d second%s" CRLF, hours, hours > 1 ? "s" : " ", minutes, minutes > 1 ? "s" : " ", (gint)uptime, uptime > 1 ? "s" : " ");
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "%d hour%s %d minute%s %d second%s" CRLF,
+ hours,
+ hours > 1 ? "s" : " ",
+ minutes,
+ minutes > 1 ? "s" : " ",
+ (gint)uptime,
+ uptime > 1 ? "s" : " ");
}
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (200, NULL, out_buf, r, session->dispatcher)) {
+ if (!restful_write_reply (200, NULL, out_buf, r,
+ session->dispatcher)) {
return FALSE;
}
}
arg = *cmd_args;
if (!arg || *arg == '\0') {
msg_debug ("no statfile specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
arg = *(cmd_args + 1);
if (arg == NULL || *arg == '\0') {
msg_debug ("no message size specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
size = strtoul (arg, &err_str, 10);
if (err_str && *err_str != '\0') {
msg_debug ("message size is invalid: %s", arg);
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn size is invalid" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
cl = rspamd_config_find_classifier (session->cfg, *cmd_args);
}
else {
- if ((arg = g_hash_table_lookup (session->kwargs, "classifier")) == NULL) {
+ if ((arg =
+ g_hash_table_lookup (session->kwargs,
+ "classifier")) == NULL) {
msg_debug ("no classifier specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
return TRUE;
else {
cl = rspamd_config_find_classifier (session->cfg, arg);
}
- if ((arg = g_hash_table_lookup (session->kwargs, "content-length")) == NULL) {
+ if ((arg =
+ g_hash_table_lookup (session->kwargs,
+ "content-length")) == NULL) {
msg_debug ("no size specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
size = strtoul (arg, &err_str, 10);
if (err_str && *err_str != '\0') {
msg_debug ("message size is invalid: %s", arg);
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn size is invalid" CRLF);
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
return TRUE;
/* By default learn positive */
session->in_class = TRUE;
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
+ rspamd_set_dispatcher_policy (session->dispatcher,
+ BUFFER_CHARACTER,
+ size);
session->state = STATE_LEARN_SPAM_PRE;
}
break;
arg = *cmd_args;
if (!arg || *arg == '\0') {
msg_debug ("no statfile specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
arg = *(cmd_args + 1);
if (arg == NULL || *arg == '\0') {
msg_debug ("no message size specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
size = strtoul (arg, &err_str, 10);
if (err_str && *err_str != '\0') {
msg_debug ("message size is invalid: %s", arg);
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn size is invalid" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
cl = rspamd_config_find_classifier (session->cfg, *cmd_args);
}
else {
- if ((arg = g_hash_table_lookup (session->kwargs, "classifier")) == NULL) {
+ if ((arg =
+ g_hash_table_lookup (session->kwargs,
+ "classifier")) == NULL) {
msg_debug ("no classifier specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
return TRUE;
else {
cl = rspamd_config_find_classifier (session->cfg, arg);
}
- if ((arg = g_hash_table_lookup (session->kwargs, "content-length")) == NULL) {
+ if ((arg =
+ g_hash_table_lookup (session->kwargs,
+ "content-length")) == NULL) {
msg_debug ("no size specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
size = strtoul (arg, &err_str, 10);
if (err_str && *err_str != '\0') {
msg_debug ("message size is invalid: %s", arg);
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn size is invalid" CRLF);
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
return TRUE;
/* By default learn positive */
session->in_class = FALSE;
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
+ rspamd_set_dispatcher_policy (session->dispatcher,
+ BUFFER_CHARACTER,
+ size);
session->state = STATE_LEARN_SPAM_PRE;
}
break;
arg = *cmd_args;
if (!arg || *arg == '\0') {
msg_debug ("no statfile specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn command requires at least two arguments: stat filename and its size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn command requires at least two arguments: stat filename and its size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
arg = *(cmd_args + 1);
if (arg == NULL || *arg == '\0') {
msg_debug ("no message size specified in learn command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn command requires at least two arguments: symbol and message size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn command requires at least two arguments: symbol and message size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
size = strtoul (arg, &err_str, 10);
if (err_str && *err_str != '\0') {
msg_debug ("message size is invalid: %s", arg);
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn size is invalid" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
}
- session->learn_symbol = rspamd_mempool_strdup (session->session_pool, *cmd_args);
- cl = g_hash_table_lookup (session->cfg->classifiers_symbols, *cmd_args);
+ session->learn_symbol = rspamd_mempool_strdup (
+ session->session_pool,
+ *cmd_args);
+ cl = g_hash_table_lookup (session->cfg->classifiers_symbols,
+ *cmd_args);
session->learn_classifier = cl;
case 'r':
arg = *(cmd_args + 1);
if (!arg || *arg == '\0') {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "recipient is not defined" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "recipient is not defined" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ out_buf, r, FALSE, FALSE)) {
return FALSE;
}
}
- session->learn_rcpt = rspamd_mempool_strdup (session->session_pool, arg);
+ session->learn_rcpt = rspamd_mempool_strdup (
+ session->session_pool,
+ arg);
break;
case 'f':
arg = *(cmd_args + 1);
if (!arg || *arg == '\0') {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "from is not defined" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "from is not defined" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ out_buf, r, FALSE, FALSE)) {
return FALSE;
}
}
- session->learn_from = rspamd_mempool_strdup (session->session_pool, arg);
+ session->learn_from = rspamd_mempool_strdup (
+ session->session_pool,
+ arg);
break;
case 'n':
session->in_class = 0;
case 'm':
arg = *(cmd_args + 1);
if (!arg || *arg == '\0') {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "multiplier is not defined" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "multiplier is not defined" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ out_buf, r, FALSE, FALSE)) {
return FALSE;
}
}
}
break;
default:
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "tokenizer is not defined" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "tokenizer is not defined" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ out_buf, r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
}
}
}
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
+ rspamd_set_dispatcher_policy (session->dispatcher,
+ BUFFER_CHARACTER,
+ size);
session->state = STATE_LEARN;
}
break;
arg = *cmd_args;
if (!arg || *arg == '\0') {
msg_debug ("no statfile specified in weights command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "weights command requires two arguments: statfile and message size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "weights command requires two arguments: statfile and message size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
arg = *(cmd_args + 1);
if (arg == NULL || *arg == '\0') {
msg_debug ("no message size specified in weights command");
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "weights command requires two arguments: statfile and message size" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "weights command requires two arguments: statfile and message size" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
size = strtoul (arg, &err_str, 10);
if (err_str && *err_str != '\0') {
msg_debug ("message size is invalid: %s", arg);
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "message size is invalid" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "message size is invalid" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
cl = g_hash_table_lookup (session->cfg->classifiers_symbols, *cmd_args);
if (cl == NULL) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "statfile %s is not defined" CRLF, *cmd_args);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "statfile %s is not defined" CRLF,
+ *cmd_args);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
}
session->learn_classifier = cl;
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
+ rspamd_set_dispatcher_policy (session->dispatcher,
+ BUFFER_CHARACTER,
+ size);
session->state = STATE_WEIGHTS;
break;
case COMMAND_SYNC:
if (!process_sync_command (session, cmd_args)) {
r = rspamd_snprintf (out_buf, sizeof (out_buf), "FAIL" CRLF);
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return TRUE;
}
break;
case COMMAND_HELP:
- r = rspamd_snprintf (out_buf, sizeof (out_buf),
- "Rspamd CLI commands (* - privileged command):" CRLF
- " help - this help message" CRLF
- "(*) learn <statfile> <size> [-r recipient] [-m multiplier] [-f from] [-n] - learn message to specified statfile" CRLF
- " quit - quit CLI session" CRLF
- " password <password> - authenticate yourself for privileged commands" CRLF
- "(*) reload - reload rspamd" CRLF
- "(*) shutdown - shutdown rspamd" CRLF
- " stat - show different rspamd stat" CRLF
- " sync - run synchronization of statfiles" CRLF
- " counters - show rspamd counters" CRLF
- " uptime - rspamd uptime" CRLF
- " weights <statfile> <size> - weight of message in all statfiles" CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "Rspamd CLI commands (* - privileged command):" CRLF
+ " help - this help message" CRLF
+ "(*) learn <statfile> <size> [-r recipient] [-m multiplier] [-f from] [-n] - learn message to specified statfile" CRLF
+ " quit - quit CLI session" CRLF
+ " password <password> - authenticate yourself for privileged commands" CRLF
+ "(*) reload - reload rspamd" CRLF
+ "(*) shutdown - shutdown rspamd" CRLF
+ " stat - show different rspamd stat" CRLF
+ " sync - run synchronization of statfiles" CRLF
+ " counters - show rspamd counters" CRLF
+ " uptime - rspamd uptime" CRLF
+ " weights <statfile> <size> - weight of message in all statfiles" CRLF);
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (200, NULL, out_buf, r, session->dispatcher)) {
+ if (!restful_write_reply (200, NULL, out_buf, r,
+ session->dispatcher)) {
return FALSE;
}
}
}
static controller_func_t
-parse_custom_command (gchar *line, gchar **cmd_args, struct controller_session *session, gsize len)
+parse_custom_command (gchar *line,
+ gchar **cmd_args,
+ struct controller_session *session,
+ gsize len)
{
- GList *cur;
+ GList *cur;
struct custom_controller_command *cmd;
if (len == 0) {
static struct controller_command *
parse_normal_command (const gchar *line, gsize len)
{
- guint i;
- struct controller_command *c;
+ guint i;
+ struct controller_command *c;
if (len == 0) {
len = strlen (line);
}
- for (i = 0; i < G_N_ELEMENTS (commands); i ++) {
+ for (i = 0; i < G_N_ELEMENTS (commands); i++) {
c = &commands[i];
if (g_ascii_strncasecmp (line, c->command, len) == 0) {
return c;
static gboolean
process_header (f_str_t *line, struct controller_session *session)
{
- gchar *headern;
- struct controller_command *command;
- struct rspamd_controller_ctx *ctx = session->worker->ctx;
- controller_func_t custom_handler;
+ gchar *headern;
+ struct controller_command *command;
+ struct rspamd_controller_ctx *ctx = session->worker->ctx;
+ controller_func_t custom_handler;
/* XXX: temporary workaround */
headern = NULL;
/* This header is actually command */
command = parse_normal_command (line->begin, line->len);
if (command == NULL) {
- if ((custom_handler = parse_custom_command (line->begin, NULL, session, line->len)) == NULL) {
+ if ((custom_handler =
+ parse_custom_command (line->begin, NULL, session,
+ line->len)) == NULL) {
msg_info ("bad command header: %V", line);
return FALSE;
}
/* Password header */
if (g_ascii_strcasecmp (headern, "password") == 0) {
if (ctx->password == NULL ||
- (line->len == strlen (ctx->password)
- && memcmp (line->begin, ctx->password, line->len) == 0)) {
+ (line->len == strlen (ctx->password)
+ && memcmp (line->begin, ctx->password, line->len) == 0)) {
session->authorized = TRUE;
}
else {
}
}
- g_hash_table_insert (session->kwargs, headern, fstrcstr (line, session->session_pool));
+ g_hash_table_insert (session->kwargs, headern,
+ fstrcstr (line, session->session_pool));
return TRUE;
}
static gboolean
fin_learn_task (void *arg)
{
- struct rspamd_task *task = (struct rspamd_task *) arg;
+ struct rspamd_task *task = (struct rspamd_task *) arg;
/* XXX: needs to be reworked */
static void
restore_learn_task (void *arg)
{
- struct rspamd_task *task = (struct rspamd_task *) arg;
+ struct rspamd_task *task = (struct rspamd_task *) arg;
/* Special state */
}
-static gboolean
+static gboolean
controller_read_socket (f_str_t * in, void *arg)
{
- struct controller_session *session = (struct controller_session *)arg;
- struct classifier_ctx *cls_ctx;
- gint len, i, r;
- gchar *s, **params, *cmd, out_buf[128];
- struct controller_command *command;
- struct rspamd_task *task;
- struct mime_text_part *part;
- GList *cur = NULL;
- GTree *tokens = NULL;
- GError *err = NULL;
- f_str_t c;
- controller_func_t custom_handler;
+ struct controller_session *session = (struct controller_session *)arg;
+ struct classifier_ctx *cls_ctx;
+ gint len, i, r;
+ gchar *s, **params, *cmd, out_buf[128];
+ struct controller_command *command;
+ struct rspamd_task *task;
+ struct mime_text_part *part;
+ GList *cur = NULL;
+ GTree *tokens = NULL;
+ GError *err = NULL;
+ f_str_t c;
+ controller_func_t custom_handler;
switch (session->state) {
case STATE_COMMAND:
s = fstrcstr (in, session->session_pool);
params = g_strsplit_set (s, " ", -1);
- rspamd_mempool_add_destructor (session->session_pool, (rspamd_mempool_destruct_t) g_strfreev, params);
+ rspamd_mempool_add_destructor (session->session_pool,
+ (rspamd_mempool_destruct_t) g_strfreev, params);
len = g_strv_length (params);
if (len > 0) {
command = parse_normal_command (cmd, 0);
if (command != NULL) {
- if (! process_command (command, ¶ms[1], session)) {
+ if (!process_command (command, ¶ms[1], session)) {
return FALSE;
}
}
else {
- if ((custom_handler = parse_custom_command (cmd, ¶ms[1], session, 0)) == NULL) {
+ if ((custom_handler =
+ parse_custom_command (cmd, ¶ms[1], session,
+ 0)) == NULL) {
msg_debug ("'%s'", cmd);
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "Unknown command" CRLF);
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "Unknown command" CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ i, FALSE, FALSE)) {
return FALSE;
}
}
}
}
}
- if (session->state != STATE_LEARN && session->state != STATE_LEARN_SPAM_PRE
- && session->state != STATE_WEIGHTS && session->state != STATE_OTHER && session->state != STATE_HEADER) {
- if (!rspamd_dispatcher_write (session->dispatcher, END, sizeof (END) - 1, FALSE, TRUE)) {
+ if (session->state != STATE_LEARN && session->state !=
+ STATE_LEARN_SPAM_PRE
+ && session->state != STATE_WEIGHTS && session->state !=
+ STATE_OTHER && session->state != STATE_HEADER) {
+ if (!rspamd_dispatcher_write (session->dispatcher, END,
+ sizeof (END) - 1, FALSE, TRUE)) {
return FALSE;
}
if (session->state == STATE_QUIT) {
if (in->len == 0) {
/* End of headers */
if (session->cmd == NULL && session->custom_handler == NULL) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Bad command" CRLF CRLF);
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Bad command" CRLF CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
+ FALSE, FALSE)) {
return FALSE;
}
destroy_session (session->s);
}
/* Perform command */
else if (session->cmd != NULL) {
- if (! process_command (session->cmd, NULL, session)) {
+ if (!process_command (session->cmd, NULL, session)) {
msg_debug ("process command failed");
return FALSE;
}
else {
session->custom_handler (NULL, session);
}
- if (session->state != STATE_LEARN && session->state != STATE_LEARN_SPAM_PRE
- && session->state != STATE_WEIGHTS && session->state != STATE_OTHER) {
+ if (session->state != STATE_LEARN && session->state !=
+ STATE_LEARN_SPAM_PRE
+ && session->state != STATE_WEIGHTS && session->state !=
+ STATE_OTHER) {
msg_debug ("closing restful connection");
destroy_session (session->s);
return FALSE;
}
}
else if (!process_header (in, session)) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Bad header" CRLF CRLF);
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Bad header" CRLF CRLF);
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
+ FALSE, FALSE)) {
return FALSE;
}
destroy_session (session->s);
rspamd_task_free (task, FALSE);
session->state = STATE_REPLY;
if (session->restful) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Cannot process message" CRLF CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Cannot process message" CRLF CRLF);
}
else {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "cannot process message" CRLF);
}
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
return FALSE;
rspamd_task_free (task, FALSE);
if (err) {
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF, err->message);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF,
+ err->message);
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: %s" CRLF END, err->message);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn failed, learn classifier error: %s" CRLF END,
+ err->message);
}
g_error_free (err);
}
else {
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, unknown learn classifier error" CRLF END);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn failed, unknown learn classifier error" CRLF END);
}
}
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
+ FALSE, FALSE)) {
return FALSE;
}
session->state = STATE_REPLY;
rspamd_task_free (task, FALSE);
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 200 Learn OK" CRLF CRLF);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 200 Learn OK" CRLF CRLF);
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn ok" CRLF END);
+ i =
+ rspamd_snprintf (out_buf, sizeof (out_buf),
+ "learn ok" CRLF END);
}
session->state = STATE_REPLY;
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE,
+ FALSE)) {
return FALSE;
}
break;
msg_warn ("processing of message failed");
session->state = STATE_REPLY;
if (session->restful) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Cannot process message" CRLF CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Cannot process message" CRLF CRLF);
}
else {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "cannot process message" CRLF);
}
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
return FALSE;
}
/* Set up async session */
- task->s = new_async_session (task->task_pool, fin_learn_task, restore_learn_task, rspamd_task_free_hard, task);
+ task->s = new_async_session (task->task_pool,
+ fin_learn_task,
+ restore_learn_task,
+ rspamd_task_free_hard,
+ task);
session->learn_task = task;
session->state = STATE_LEARN_SPAM;
rspamd_dispatcher_pause (session->dispatcher);
rspamd_dispatcher_restore (session->dispatcher);
session->state = STATE_REPLY;
if (session->restful) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Cannot process message" CRLF CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Cannot process message" CRLF CRLF);
}
else {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "cannot process message" CRLF);
}
destroy_session (task->s);
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
msg_warn ("processing of message failed");
rspamd_task_free (task, FALSE);
session->state = STATE_REPLY;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF END);
+ r = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "cannot process message" CRLF END);
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
c.begin = part->content->data;
c.len = part->content->len;
- if (!session->learn_classifier->tokenizer->tokenize_func (session->learn_classifier->tokenizer,
- session->session_pool, &c, &tokens, FALSE, part->is_utf, part->urls_offset)) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "weights failed, tokenizer error" CRLF END);
+ if (!session->learn_classifier->tokenizer->tokenize_func (session->
+ learn_classifier->tokenizer,
+ session->session_pool, &c, &tokens, FALSE, part->is_utf,
+ part->urls_offset)) {
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "weights failed, tokenizer error" CRLF END);
rspamd_task_free (task, FALSE);
if (!session->restful) {
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
+ r, FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
+ if (!restful_write_reply (500, out_buf, NULL, 0,
+ session->dispatcher)) {
return FALSE;
}
}
}
cur = g_list_next (cur);
}
-
+
/* Handle messages without text */
if (tokens == NULL) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "weights failed, no tokens can be extracted (no text data)" CRLF END);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "weights failed, no tokens can be extracted (no text data)" CRLF END);
rspamd_task_free (task, FALSE);
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
+ FALSE, FALSE)) {
return FALSE;
}
session->state = STATE_REPLY;
return TRUE;
}
-
-
+
+
/* Init classifier */
- cls_ctx = session->learn_classifier->classifier->init_func (session->session_pool, session->learn_classifier);
-
- cur = session->learn_classifier->classifier->weights_func (cls_ctx, session->worker->srv->statfile_pool,
- tokens, task);
+ cls_ctx = session->learn_classifier->classifier->init_func (
+ session->session_pool,
+ session->learn_classifier);
+
+ cur = session->learn_classifier->classifier->weights_func (cls_ctx,
+ session->worker->srv->statfile_pool,
+ tokens,
+ task);
i = 0;
struct classify_weight *w;
while (cur) {
w = cur->data;
- i += rspamd_snprintf (out_buf + i, sizeof (out_buf) - i, "%s: %G" CRLF, w->name, w->weight);
+ i += rspamd_snprintf (out_buf + i,
+ sizeof (out_buf) - i,
+ "%s: %G" CRLF,
+ w->name,
+ w->weight);
cur = g_list_next (cur);
}
i += rspamd_snprintf (out_buf + i, sizeof (out_buf) - i, END);
if (i != 0) {
- if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
+ FALSE, FALSE)) {
return FALSE;
}
}
else {
- if (!rspamd_dispatcher_write (session->dispatcher, "weights failed: classifier error" CRLF END, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ "weights failed: classifier error" CRLF END, 0, FALSE, TRUE)) {
return FALSE;
}
}
return TRUE;
}
-static gboolean
+static gboolean
controller_write_socket (void *arg)
{
- struct controller_session *session = (struct controller_session *)arg;
- gint i;
- gchar out_buf[1024];
- GError *err = NULL;
+ struct controller_session *session = (struct controller_session *)arg;
+ gint i;
+ gchar out_buf[1024];
+ GError *err = NULL;
if (session->state == STATE_QUIT) {
/* Free buffers */
/* Perform actual learn here */
if (session->learn_classifier == NULL) {
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF, "unknown classifier");
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF,
+ "unknown classifier");
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: %s" CRLF END, "unknown classifier");
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn failed, learn classifier error: %s" CRLF END,
+ "unknown classifier");
}
}
else {
- if (! learn_task_spam (session->learn_classifier, session->learn_task, session->in_class, &err)) {
+ if (!learn_task_spam (session->learn_classifier,
+ session->learn_task, session->in_class, &err)) {
if (err) {
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF, err->message);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF,
+ err->message);
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: %s" CRLF END, err->message);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn failed, learn classifier error: %s" CRLF END,
+ err->message);
}
g_error_free (err);
}
else {
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: unknown" CRLF END);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn failed, learn classifier error: unknown" CRLF END);
}
}
}
else {
if (session->restful) {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 200 Learn OK" CRLF CRLF);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "HTTP/1.0 200 Learn OK" CRLF CRLF);
}
else {
- i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn ok" CRLF END);
+ i = rspamd_snprintf (out_buf,
+ sizeof (out_buf),
+ "learn ok" CRLF END);
}
}
}
destroy_session (session->learn_task->s);
session->state = STATE_REPLY;
- if (! rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE,
+ FALSE)) {
return FALSE;
}
if (session->restful) {
}
else {
session->state = STATE_COMMAND;
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, BUFSIZ);
+ rspamd_set_dispatcher_policy (session->dispatcher,
+ BUFFER_LINE,
+ BUFSIZ);
}
}
rspamd_dispatcher_restore (session->dispatcher);
static void
controller_err_socket (GError * err, void *arg)
{
- struct controller_session *session = (struct controller_session *)arg;
+ struct controller_session *session = (struct controller_session *)arg;
if (err->code != EOF) {
- msg_info ("abnormally closing control connection, error: %s", err->message);
+ msg_info ("abnormally closing control connection, error: %s",
+ err->message);
}
g_error_free (err);
/* Free buffers */
static void
accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- union sa_union su;
- struct controller_session *new_session;
- struct timeval *io_tv;
- gint nfd;
- struct rspamd_controller_ctx *ctx;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ union sa_union su;
+ struct controller_session *new_session;
+ struct timeval *io_tv;
+ gint nfd;
+ struct rspamd_controller_ctx *ctx;
rspamd_inet_addr_t addr;
ctx = worker->ctx;
new_session->sock = nfd;
new_session->cfg = worker->srv->cfg;
new_session->state = STATE_COMMAND;
- new_session->session_pool = rspamd_mempool_new (rspamd_mempool_suggest_size () - 1);
+ new_session->session_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size () - 1);
new_session->resolver = ctx->resolver;
new_session->ev_base = ctx->ev_base;
if (ctx->password == NULL) {
worker->srv->stat->control_connections_count++;
/* Set up dispatcher */
- io_tv = rspamd_mempool_alloc (new_session->session_pool, sizeof (struct timeval));
+ io_tv =
+ rspamd_mempool_alloc (new_session->session_pool,
+ sizeof (struct timeval));
io_tv->tv_sec = ctx->timeout / 1000;
io_tv->tv_usec = ctx->timeout - io_tv->tv_sec * 1000;
- new_session->s = new_async_session (new_session->session_pool, NULL, NULL, free_session, new_session);
-
- new_session->dispatcher = rspamd_create_dispatcher (ctx->ev_base, nfd, BUFFER_LINE, controller_read_socket,
- controller_write_socket, controller_err_socket, io_tv, (void *)new_session);
+ new_session->s = new_async_session (new_session->session_pool,
+ NULL,
+ NULL,
+ free_session,
+ new_session);
+
+ new_session->dispatcher = rspamd_create_dispatcher (ctx->ev_base,
+ nfd,
+ BUFFER_LINE,
+ controller_read_socket,
+ controller_write_socket,
+ controller_err_socket,
+ io_tv,
+ (void *)new_session);
if (su.ss.ss_family == AF_UNIX) {
msg_info ("accepted connection from unix socket");
}
else if (su.ss.ss_family == AF_INET) {
msg_info ("accepted connection from %s port %d",
- inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
+ inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
memcpy (&new_session->dispatcher->peer_addr, &su.s4.sin_addr,
- sizeof (guint32));
+ sizeof (guint32));
}
#if 0
/* As we support now restful HTTP like connections, this should not be printed anymore */
- if (! rspamd_dispatcher_write (new_session->dispatcher, greetingbuf, strlen (greetingbuf), FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (new_session->dispatcher, greetingbuf,
+ strlen (greetingbuf), FALSE, FALSE)) {
msg_warn ("cannot write greeting");
}
#endif
static gboolean
create_rrd_file (const gchar *filename, struct rspamd_controller_ctx *ctx)
{
- GError *err = NULL;
- GArray ar;
- struct rrd_rra_def rra[5];
- struct rrd_ds_def ds[4];
+ GError *err = NULL;
+ GArray ar;
+ struct rrd_rra_def rra[5];
+ struct rrd_ds_def ds[4];
/*
* DS:
* 4) per 2 hours AVERAGE
* 5) per day AVERAGE
*/
- ctx->rrd_file = rspamd_rrd_create (filename, 4, 5, CONTROLLER_RRD_STEP, &err);
+ ctx->rrd_file =
+ rspamd_rrd_create (filename, 4, 5, CONTROLLER_RRD_STEP, &err);
if (ctx->rrd_file == NULL) {
- msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
+ msg_err ("cannot create rrd file %s, error: %s", filename,
+ err->message);
g_error_free (err);
return FALSE;
}
/* Add all ds and rra */
- rrd_make_default_ds ("spam", CONTROLLER_RRD_STEP, &ds[0]);
+ rrd_make_default_ds ("spam", CONTROLLER_RRD_STEP, &ds[0]);
rrd_make_default_ds ("possible spam", CONTROLLER_RRD_STEP, &ds[1]);
- rrd_make_default_ds ("greylist", CONTROLLER_RRD_STEP, &ds[2]);
- rrd_make_default_ds ("ham", CONTROLLER_RRD_STEP, &ds[3]);
+ rrd_make_default_ds ("greylist", CONTROLLER_RRD_STEP, &ds[2]);
+ rrd_make_default_ds ("ham", CONTROLLER_RRD_STEP, &ds[3]);
- rrd_make_default_rra ("AVERAGE", 1, 600, &rra[0]);
- rrd_make_default_rra ("AVERAGE", 5, 600, &rra[1]);
- rrd_make_default_rra ("AVERAGE", 30, 700, &rra[2]);
- rrd_make_default_rra ("AVERAGE", 120, 775, &rra[3]);
+ rrd_make_default_rra ("AVERAGE", 1, 600, &rra[0]);
+ rrd_make_default_rra ("AVERAGE", 5, 600, &rra[1]);
+ rrd_make_default_rra ("AVERAGE", 30, 700, &rra[2]);
+ rrd_make_default_rra ("AVERAGE", 120, 775, &rra[3]);
rrd_make_default_rra ("AVERAGE", 1440, 797, &rra[4]);
ar.data = (gchar *)ds;
ar.len = sizeof (ds);
if (!rspamd_rrd_add_ds (ctx->rrd_file, &ar, &err)) {
- msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
+ msg_err ("cannot create rrd file %s, error: %s", filename,
+ err->message);
g_error_free (err);
rspamd_rrd_close (ctx->rrd_file);
return FALSE;
ar.data = (gchar *)rra;
ar.len = sizeof (rra);
if (!rspamd_rrd_add_rra (ctx->rrd_file, &ar, &err)) {
- msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
+ msg_err ("cannot create rrd file %s, error: %s", filename,
+ err->message);
g_error_free (err);
rspamd_rrd_close (ctx->rrd_file);
return FALSE;
/* Finalize */
if (!rspamd_rrd_finalize (ctx->rrd_file, &err)) {
- msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
+ msg_err ("cannot create rrd file %s, error: %s", filename,
+ err->message);
g_error_free (err);
rspamd_rrd_close (ctx->rrd_file);
return FALSE;
static void
controller_update_rrd (gint fd, short what, void *arg)
{
- struct rspamd_controller_ctx *ctx = arg;
- struct timeval tv;
- GArray ar;
- gdouble data[4];
- GError *err = NULL;
+ struct rspamd_controller_ctx *ctx = arg;
+ struct timeval tv;
+ GArray ar;
+ gdouble data[4];
+ GError *err = NULL;
/*
* Data:
/* Fill data */
data[0] = ctx->srv->stat->actions_stat[METRIC_ACTION_REJECT];
- data[1] = ctx->srv->stat->actions_stat[METRIC_ACTION_ADD_HEADER] + ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
+ data[1] = ctx->srv->stat->actions_stat[METRIC_ACTION_ADD_HEADER] +
+ ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
data[2] = ctx->srv->stat->actions_stat[METRIC_ACTION_GREYLIST];
data[3] = ctx->srv->stat->actions_stat[METRIC_ACTION_NOACTION];
ar.data = (gchar *)data;
ar.len = sizeof (data);
if (!rspamd_rrd_add_record (ctx->rrd_file, &ar, &err)) {
- msg_err ("cannot add record to rrd database: %s, stop rrd update", err->message);
+ msg_err ("cannot add record to rrd database: %s, stop rrd update",
+ err->message);
g_error_free (err);
}
else {
gpointer
init_controller (struct rspamd_config *cfg)
{
- struct rspamd_controller_ctx *ctx;
- GQuark type;
+ struct rspamd_controller_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("controller");
ctx = g_malloc0 (sizeof (struct rspamd_controller_ctx));
ctx->timeout = CONTROLLER_IO_TIMEOUT * 1000;
rspamd_rcl_register_worker_option (cfg, type, "password",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_ctx, password), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_ctx, password), 0);
rspamd_rcl_register_worker_option (cfg, type, "timeout",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct rspamd_controller_ctx, timeout), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct rspamd_controller_ctx,
+ timeout), RSPAMD_CL_FLAG_TIME_UINT_32);
return ctx;
}
void
start_controller (struct rspamd_worker *worker)
{
- gchar *hostbuf;
- gsize hostmax;
- struct rspamd_controller_ctx *ctx = worker->ctx;
- GError *err = NULL;
- struct timeval tv;
+ gchar *hostbuf;
+ gsize hostmax;
+ struct rspamd_controller_ctx *ctx = worker->ctx;
+ GError *err = NULL;
+ struct timeval tv;
ctx->ev_base = rspamd_prepare_worker (worker, "controller", accept_socket);
g_mime_init (0);
start_time = time (NULL);
/* Start statfile synchronization */
- if (!start_statfile_sync (worker->srv->statfile_pool, worker->srv->cfg, ctx->ev_base)) {
- msg_info ("cannot start statfile synchronization, statfiles would not be synchronized");
+ if (!start_statfile_sync (worker->srv->statfile_pool, worker->srv->cfg,
+ ctx->ev_base)) {
+ msg_info (
+ "cannot start statfile synchronization, statfiles would not be synchronized");
}
/* Check for rrd */
if (worker->srv->cfg->rrd_file) {
ctx->rrd_file = rspamd_rrd_open (worker->srv->cfg->rrd_file, &err);
if (ctx->rrd_file == NULL) {
- msg_info ("cannot open rrd file: %s, error: %s, trying to create", worker->srv->cfg->rrd_file, err->message);
+ msg_info ("cannot open rrd file: %s, error: %s, trying to create",
+ worker->srv->cfg->rrd_file,
+ err->message);
g_error_free (err);
/* Try to create rrd file */
if (create_rrd_file (worker->srv->cfg->rrd_file, ctx)) {
hostbuf = alloca (hostmax);
gethostname (hostbuf, hostmax);
hostbuf[hostmax - 1] = '\0';
- rspamd_snprintf (greetingbuf, sizeof (greetingbuf), "Rspamd version %s is running on %s" CRLF, RVERSION, hostbuf);
+ rspamd_snprintf (greetingbuf,
+ sizeof (greetingbuf),
+ "Rspamd version %s is running on %s" CRLF,
+ RVERSION,
+ hostbuf);
start_map_watch (worker->srv->cfg, ctx->ev_base);
- ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
+ ctx->resolver = dns_resolver_init (worker->srv->logger,
+ ctx->ev_base,
+ worker->srv->cfg);
event_base_loop (ctx->ev_base, 0);
}
void
-register_custom_controller_command (const gchar *name, controller_func_t handler, gboolean privilleged, gboolean require_message)
+register_custom_controller_command (const gchar *name,
+ controller_func_t handler,
+ gboolean privilleged,
+ gboolean require_message)
{
struct custom_controller_command *cmd;
custom_commands = g_list_prepend (custom_commands, cmd);
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
-#include "util.h"
#include "cfg_file.h"
-#include "main.h"
-#include "message.h"
-#include "fuzzy.h"
+#include "config.h"
+#include "diff.h"
#include "expressions.h"
+#include "fuzzy.h"
#include "html.h"
#include "lua/lua_common.h"
-#include "diff.h"
+#include "main.h"
+#include "message.h"
+#include "util.h"
-gboolean rspamd_compare_encoding (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_header_exists (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_parts_distance (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_recipients_distance (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_has_only_html_part (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_is_recipients_sorted (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_compare_transfer_encoding (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_is_html_balanced (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_has_html_tag (struct rspamd_task *task, GList * args, void *unused);
-gboolean rspamd_has_fake_html (struct rspamd_task *task, GList * args, void *unused);
+gboolean rspamd_compare_encoding (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_header_exists (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_parts_distance (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_recipients_distance (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_has_only_html_part (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_is_recipients_sorted (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_compare_transfer_encoding (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_is_html_balanced (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_has_html_tag (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+gboolean rspamd_has_fake_html (struct rspamd_task *task,
+ GList * args,
+ void *unused);
/*
* List of internal functions of rspamd
* Sorted by name to use bsearch
*/
static struct _fl {
- const gchar *name;
- rspamd_internal_func_t func;
- void *user_data;
+ const gchar *name;
+ rspamd_internal_func_t func;
+ void *user_data;
} rspamd_functions_list[] = {
{"compare_encoding", rspamd_compare_encoding, NULL},
{"compare_parts_distance", rspamd_parts_distance, NULL},
{"is_recipients_sorted", rspamd_is_recipients_sorted, NULL}
};
-static struct _fl *list_ptr = &rspamd_functions_list[0];
-static guint32 functions_number = sizeof (rspamd_functions_list) / sizeof (struct _fl);
-static gboolean list_allocated = FALSE;
+static struct _fl *list_ptr = &rspamd_functions_list[0];
+static guint32 functions_number = sizeof (rspamd_functions_list) /
+ sizeof (struct _fl);
+static gboolean list_allocated = FALSE;
/* Bsearch routine */
static gint
fl_cmp (const void *s1, const void *s2)
{
- struct _fl *fl1 = (struct _fl *)s1;
- struct _fl *fl2 = (struct _fl *)s2;
+ struct _fl *fl1 = (struct _fl *)s1;
+ struct _fl *fl2 = (struct _fl *)s2;
return strcmp (fl1->name, fl2->name);
}
/* Cache for regular expressions that are used in functions */
-void *
+void *
re_cache_check (const gchar *line, rspamd_mempool_t *pool)
{
- GHashTable *re_cache;
-
+ GHashTable *re_cache;
+
re_cache = rspamd_mempool_get_variable (pool, "re_cache");
if (re_cache == NULL) {
re_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
- rspamd_mempool_set_variable (pool, "re_cache", re_cache, (rspamd_mempool_destruct_t)g_hash_table_destroy);
+ rspamd_mempool_set_variable (pool, "re_cache", re_cache,
+ (rspamd_mempool_destruct_t)g_hash_table_destroy);
return NULL;
}
return g_hash_table_lookup (re_cache, line);
void
re_cache_add (const gchar *line, void *pointer, rspamd_mempool_t *pool)
{
- GHashTable *re_cache;
-
+ GHashTable *re_cache;
+
re_cache = rspamd_mempool_get_variable (pool, "re_cache");
if (re_cache == NULL) {
re_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
- rspamd_mempool_set_variable (pool, "re_cache", re_cache, (rspamd_mempool_destruct_t)g_hash_table_destroy);
+ rspamd_mempool_set_variable (pool, "re_cache", re_cache,
+ (rspamd_mempool_destruct_t)g_hash_table_destroy);
}
g_hash_table_insert (re_cache, (gpointer)line, pointer);
void
re_cache_del (const gchar *line, rspamd_mempool_t *pool)
{
- GHashTable *re_cache;
+ GHashTable *re_cache;
re_cache = rspamd_mempool_get_variable (pool, "re_cache");
* Functions for parsing expressions
*/
struct expression_stack {
- gchar op;
- struct expression_stack *next;
+ gchar op;
+ struct expression_stack *next;
};
/*
- * Push operand or operator to stack
+ * Push operand or operator to stack
*/
static struct expression_stack *
-push_expression_stack (rspamd_mempool_t * pool, struct expression_stack *head, gchar op)
+push_expression_stack (rspamd_mempool_t * pool,
+ struct expression_stack *head,
+ gchar op)
{
- struct expression_stack *new;
+ struct expression_stack *new;
new = rspamd_mempool_alloc (pool, sizeof (struct expression_stack));
new->op = op;
new->next = head;
static gchar
delete_expression_stack (struct expression_stack **head)
{
- struct expression_stack *cur;
- gchar res;
+ struct expression_stack *cur;
+ gchar res;
if (*head == NULL)
return 0;
* Return FALSE if symbol is not operation symbol (operand)
* Return TRUE if symbol is operation symbol
*/
-static gboolean
+static gboolean
is_operation_symbol (gchar *a)
{
switch (*a) {
return TRUE;
case 'O':
case 'o':
- if (g_ascii_strncasecmp (a, "or", sizeof ("or") - 1) == 0&& g_ascii_isspace (a[2])) {
+ if (g_ascii_strncasecmp (a, "or",
+ sizeof ("or") - 1) == 0 && g_ascii_isspace (a[2])) {
return TRUE;
}
break;
case 'A':
case 'a':
- if (g_ascii_strncasecmp (a, "and", sizeof ("and") - 1) == 0&& g_ascii_isspace (a[3])) {
+ if (g_ascii_strncasecmp (a, "and",
+ sizeof ("and") - 1) == 0 && g_ascii_isspace (a[3])) {
return TRUE;
}
break;
case 'N':
case 'n':
- if (g_ascii_strncasecmp (a, "not", sizeof ("not") - 1) == 0 && g_ascii_isspace (a[3])) {
+ if (g_ascii_strncasecmp (a, "not",
+ sizeof ("not") - 1) == 0 && g_ascii_isspace (a[3])) {
return TRUE;
}
break;
/*
* Return TRUE if symbol can be regexp flag
*/
-static gboolean
+static gboolean
is_regexp_flag (gchar a)
{
switch (a) {
}
static void
-insert_expression (rspamd_mempool_t * pool, struct expression **head, gint type, gchar op, void *operand, const gchar *orig)
+insert_expression (rspamd_mempool_t * pool,
+ struct expression **head,
+ gint type,
+ gchar op,
+ void *operand,
+ const gchar *orig)
{
- struct expression *new, *cur;
+ struct expression *new, *cur;
new = rspamd_mempool_alloc (pool, sizeof (struct expression));
new->type = type;
}
}
-static struct expression *
+static struct expression *
maybe_parse_expression (rspamd_mempool_t * pool, gchar *line)
{
- struct expression *expr;
- gchar *p = line;
+ struct expression *expr;
+ gchar *p = line;
while (*p) {
if (is_operation_symbol (p)) {
* Make inverse polish record for specified expression
* Memory is allocated from given pool
*/
-struct expression *
+struct expression *
parse_expression (rspamd_mempool_t * pool, gchar *line)
{
- struct expression *expr = NULL;
- struct expression_stack *stack = NULL;
- struct expression_function *func = NULL;
- struct expression *arg;
- GQueue *function_stack;
- gchar *p, *c, *str, op, newop, *copy, *next;
- gboolean in_regexp = FALSE;
- gint brackets = 0;
+ struct expression *expr = NULL;
+ struct expression_stack *stack = NULL;
+ struct expression_function *func = NULL;
+ struct expression *arg;
+ GQueue *function_stack;
+ gchar *p, *c, *str, op, newop, *copy, *next;
+ gboolean in_regexp = FALSE;
+ gint brackets = 0;
enum {
SKIP_SPACES,
while (stack && stack->op != '(') {
op = delete_expression_stack (&stack);
if (op != '(') {
- insert_expression (pool, &expr, EXPR_OPERATION, op, NULL, copy);
+ insert_expression (pool,
+ &expr,
+ EXPR_OPERATION,
+ op,
+ NULL,
+ copy);
}
}
if (stack) {
else {
newop = op_to_char (p, &next);
if (newop != '\0') {
- if (logic_priority (stack->op) < logic_priority (newop)) {
+ if (logic_priority (stack->op) <
+ logic_priority (newop)) {
stack = push_expression_stack (pool, stack, newop);
}
else {
/* Pop all operations that have higher priority than this one */
- while ((stack != NULL) && (logic_priority (stack->op) >= logic_priority (newop))) {
+ while ((stack != NULL) &&
+ (logic_priority (stack->op) >=
+ logic_priority (newop))) {
op = delete_expression_stack (&stack);
if (op != '(') {
- insert_expression (pool, &expr, EXPR_OPERATION, op, NULL, copy);
+ insert_expression (pool,
+ &expr,
+ EXPR_OPERATION,
+ op,
+ NULL,
+ copy);
}
}
stack = push_expression_stack (pool, stack, newop);
case READ_REGEXP_FLAGS:
if (!is_regexp_flag (*p) || *(p + 1) == '\0') {
if (c != p) {
- if ((is_regexp_flag (*p) || *p == '/') && *(p + 1) == '\0') {
+ if ((is_regexp_flag (*p) || *p ==
+ '/') && *(p + 1) == '\0') {
p++;
}
str = rspamd_mempool_alloc (pool, p - c + 2);
g_strstrip (str);
msg_debug ("found regexp: %s", str);
if (strlen (str) > 0) {
- insert_expression (pool, &expr, EXPR_REGEXP, 0, str, copy);
+ insert_expression (pool,
+ &expr,
+ EXPR_REGEXP,
+ 0,
+ str,
+ copy);
}
}
c = p;
p++;
}
else if (*p == '(') {
- func = rspamd_mempool_alloc (pool, sizeof (struct expression_function));
+ func =
+ rspamd_mempool_alloc (pool,
+ sizeof (struct expression_function));
func->name = rspamd_mempool_alloc (pool, p - c + 1);
func->args = NULL;
rspamd_strlcpy (func->name, c, (p - c + 1));
/*
* Rspamd regexp utility functions
*/
-struct rspamd_regexp *
+struct rspamd_regexp *
parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
{
- const gchar *begin, *end, *p, *src, *start;
- gchar *dbegin, *dend;
- struct rspamd_regexp *result, *check;
- gint regexp_flags = G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE;
- GError *err = NULL;
+ const gchar *begin, *end, *p, *src, *start;
+ gchar *dbegin, *dend;
+ struct rspamd_regexp *result, *check;
+ gint regexp_flags = G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE;
+ GError *err = NULL;
if (line == NULL) {
msg_err ("cannot parse NULL line");
end = p;
break;
}
- p --;
+ p--;
}
if (end) {
result->header = rspamd_mempool_alloc (pool, end - line + 1);
}
else {
/* We got header name earlier but have not found // expression, so it is invalid regexp */
- msg_warn ("got no header name (eg. header=) but without corresponding regexp, %s", src);
+ msg_warn (
+ "got no header name (eg. header=) but without corresponding regexp, %s",
+ src);
return NULL;
}
/* Find end */
result->is_raw = TRUE;
p++;
break;
- /* Type flags */
+ /* Type flags */
case 'H':
if (result->type == REGEXP_NONE) {
result->type = REGEXP_HEADER;
break;
case 'T':
result->is_test = TRUE;
- p ++;
+ p++;
break;
case 'S':
result->is_strong = TRUE;
- p ++;
+ p++;
break;
- /* Stop flags parsing */
+ /* Stop flags parsing */
default:
p = NULL;
break;
}
/* Avoid multiply regexp structures for similar regexps */
- if ((check = (struct rspamd_regexp *)re_cache_check (result->regexp_text, pool)) != NULL) {
+ if ((check =
+ (struct rspamd_regexp *)re_cache_check (result->regexp_text,
+ pool)) != NULL) {
/* Additional check for headers */
- if (result->type == REGEXP_HEADER || result->type == REGEXP_RAW_HEADER) {
+ if (result->type == REGEXP_HEADER || result->type ==
+ REGEXP_RAW_HEADER) {
if (result->header && check->header) {
if (strcmp (result->header, check->header) == 0) {
return check;
result->raw_regexp = result->regexp;
}
else {
- result->raw_regexp = g_regex_new (dbegin, regexp_flags | G_REGEX_RAW, 0, &err);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_regex_unref, (void *)result->raw_regexp);
- }
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_regex_unref, (void *)result->regexp);
+ result->raw_regexp = g_regex_new (dbegin,
+ regexp_flags | G_REGEX_RAW,
+ 0,
+ &err);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_regex_unref,
+ (void *)result->raw_regexp);
+ }
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_regex_unref,
+ (void *)result->regexp);
*dend = '/';
if (result->regexp == NULL || err != NULL) {
- msg_warn ("could not read regexp: %s while reading regexp %s", err->message, src);
+ msg_warn ("could not read regexp: %s while reading regexp %s",
+ err->message,
+ src);
return NULL;
}
if (result->raw_regexp == NULL || err != NULL) {
- msg_warn ("could not read raw regexp: %s while reading regexp %s", err->message, src);
+ msg_warn ("could not read raw regexp: %s while reading regexp %s",
+ err->message,
+ src);
return NULL;
}
}
gboolean
-call_expression_function (struct expression_function * func, struct rspamd_task * task, lua_State *L)
+call_expression_function (struct expression_function * func,
+ struct rspamd_task * task,
+ lua_State *L)
{
- struct _fl *selected, key;
+ struct _fl *selected, key;
key.name = func->name;
- selected = bsearch (&key, list_ptr, functions_number, sizeof (struct _fl), fl_cmp);
+ selected = bsearch (&key,
+ list_ptr,
+ functions_number,
+ sizeof (struct _fl),
+ fl_cmp);
if (selected == NULL) {
/* Try to check lua function */
return FALSE;
return selected->func (task, func->args, selected->user_data);
}
-struct expression_argument *
-get_function_arg (struct expression *expr, struct rspamd_task *task, gboolean want_string)
+struct expression_argument *
+get_function_arg (struct expression *expr,
+ struct rspamd_task *task,
+ gboolean want_string)
{
- GQueue *stack;
- gsize cur, op1, op2;
- struct expression_argument *res;
- struct expression *it;
+ GQueue *stack;
+ gsize cur, op1, op2;
+ struct expression_argument *res;
+ struct expression *it;
if (expr == NULL) {
msg_warn ("NULL expression passed");
return NULL;
}
if (expr->next == NULL) {
- res = rspamd_mempool_alloc (task->task_pool, sizeof (struct expression_argument));
- if (expr->type == EXPR_REGEXP || expr->type == EXPR_STR || expr->type == EXPR_REGEXP_PARSED) {
+ res =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct expression_argument));
+ if (expr->type == EXPR_REGEXP || expr->type == EXPR_STR || expr->type ==
+ EXPR_REGEXP_PARSED) {
res->type = EXPRESSION_ARGUMENT_NORMAL;
res->data = expr->content.operand;
}
res->data = GSIZE_TO_POINTER (cur);
}
else {
- msg_warn ("cannot parse argument: it contains operator or bool expression that is not wanted");
+ msg_warn (
+ "cannot parse argument: it contains operator or bool expression that is not wanted");
return NULL;
}
return res;
}
else if (!want_string) {
- res = rspamd_mempool_alloc (task->task_pool, sizeof (struct expression_argument));
+ res =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct expression_argument));
res->type = EXPRESSION_ARGUMENT_BOOL;
stack = g_queue_new ();
it = expr;
while (it) {
- if (it->type == EXPR_REGEXP || it->type == EXPR_REGEXP_PARSED || it->type == EXPR_STR) {
+ if (it->type == EXPR_REGEXP || it->type == EXPR_REGEXP_PARSED ||
+ it->type == EXPR_STR) {
g_queue_free (stack);
res->type = EXPRESSION_ARGUMENT_EXPR;
res->data = expr;
return res;
}
else if (it->type == EXPR_FUNCTION) {
- cur = (gsize) call_expression_function ((struct expression_function *)it->content.operand, task, NULL);
- debug_task ("function %s returned %s", ((struct expression_function *)it->content.operand)->name, cur ? "true" : "false");
+ cur =
+ (gsize) call_expression_function ((struct
+ expression_function
+ *)it->content.operand, task, NULL);
+ debug_task ("function %s returned %s",
+ ((struct expression_function *)it->content.operand)->name,
+ cur ? "true" : "false");
}
else if (it->type == EXPR_OPERATION) {
if (g_queue_is_empty (stack)) {
}
void
-register_expression_function (const gchar *name, rspamd_internal_func_t func, void *user_data)
+register_expression_function (const gchar *name,
+ rspamd_internal_func_t func,
+ void *user_data)
{
- static struct _fl *new;
+ static struct _fl *new;
functions_number++;
gboolean
rspamd_compare_encoding (struct rspamd_task *task, GList * args, void *unused)
{
- struct expression_argument *arg;
+ struct expression_argument *arg;
if (args == NULL || task == NULL) {
return FALSE;
gboolean
rspamd_header_exists (struct rspamd_task * task, GList * args, void *unused)
{
- struct expression_argument *arg;
- GList *headerlist;
+ struct expression_argument *arg;
+ GList *headerlist;
if (args == NULL || task == NULL) {
return FALSE;
}
debug_task ("try to get header %s", (gchar *)arg->data);
- headerlist = message_get_header (task->task_pool, task->message, (gchar *)arg->data, FALSE);
+ headerlist = message_get_header (task->task_pool,
+ task->message,
+ (gchar *)arg->data,
+ FALSE);
if (headerlist) {
g_list_free (headerlist);
return TRUE;
/*
* This function is designed to find difference between text/html and text/plain parts
- * It takes one argument: difference threshold, if we have two text parts, compare
+ * It takes one argument: difference threshold, if we have two text parts, compare
* its hashes and check for threshold, if value is greater than threshold, return TRUE
* and return FALSE otherwise.
*/
gboolean
rspamd_parts_distance (struct rspamd_task * task, GList * args, void *unused)
{
- gint threshold, threshold2 = -1, diff;
- struct mime_text_part *p1, *p2;
- GList *cur;
- struct expression_argument *arg;
- GMimeObject *parent;
- const GMimeContentType *ct;
- gint *pdiff;
+ gint threshold, threshold2 = -1, diff;
+ struct mime_text_part *p1, *p2;
+ GList *cur;
+ struct expression_argument *arg;
+ GMimeObject *parent;
+ const GMimeContentType *ct;
+ gint *pdiff;
if (args == NULL) {
debug_task ("no threshold is specified, assume it 100");
arg = get_function_arg (args->data, task, TRUE);
threshold = strtoul ((gchar *)arg->data, NULL, 10);
if (errno != 0) {
- msg_info ("bad numeric value for threshold \"%s\", assume it 100", (gchar *)args->data);
+ msg_info ("bad numeric value for threshold \"%s\", assume it 100",
+ (gchar *)args->data);
threshold = 100;
}
if (args->next) {
errno = 0;
threshold2 = strtoul ((gchar *)arg->data, NULL, 10);
if (errno != 0) {
- msg_info ("bad numeric value for threshold \"%s\", ignore it", (gchar *)arg->data);
+ msg_info ("bad numeric value for threshold \"%s\", ignore it",
+ (gchar *)arg->data);
threshold2 = -1;
}
}
}
- if ((pdiff = rspamd_mempool_get_variable (task->task_pool, "parts_distance")) != NULL) {
+ if ((pdiff =
+ rspamd_mempool_get_variable (task->task_pool,
+ "parts_distance")) != NULL) {
diff = *pdiff;
if (diff != -1) {
if (threshold2 > 0) {
- if (diff >= MIN (threshold, threshold2) && diff < MAX (threshold, threshold2)) {
+ if (diff >=
+ MIN (threshold,
+ threshold2) && diff < MAX (threshold, threshold2)) {
return TRUE;
}
}
parent = p1->parent;
ct = g_mime_object_get_content_type (parent);
#ifndef GMIME24
- if (ct == NULL || ! g_mime_content_type_is_type (ct, "multipart", "alternative")) {
+ if (ct == NULL ||
+ !g_mime_content_type_is_type (ct, "multipart", "alternative")) {
#else
- if (ct == NULL || ! g_mime_content_type_is_type ((GMimeContentType *)ct, "multipart", "alternative")) {
+ if (ct == NULL ||
+ !g_mime_content_type_is_type ((GMimeContentType *)ct,
+ "multipart", "alternative")) {
#endif
- debug_task ("two parts are not belong to multipart/alternative container, skip check");
- rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
+ debug_task (
+ "two parts are not belong to multipart/alternative container, skip check");
+ rspamd_mempool_set_variable (task->task_pool,
+ "parts_distance",
+ pdiff,
+ NULL);
return FALSE;
}
}
else {
- debug_task ("message contains two parts but they are in different multi-parts");
- rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
+ debug_task (
+ "message contains two parts but they are in different multi-parts");
+ rspamd_mempool_set_variable (task->task_pool,
+ "parts_distance",
+ pdiff,
+ NULL);
return FALSE;
}
if (!p1->is_empty && !p2->is_empty) {
if (p1->diff_str != NULL && p2->diff_str != NULL) {
- diff = compare_diff_distance_normalized (p1->diff_str, p2->diff_str);
+ diff = compare_diff_distance_normalized (p1->diff_str,
+ p2->diff_str);
}
else {
diff = fuzzy_compare_parts (p1, p2);
}
- debug_task ("got likeliness between parts of %d%%, threshold is %d%%", diff, threshold);
+ debug_task (
+ "got likeliness between parts of %d%%, threshold is %d%%",
+ diff,
+ threshold);
*pdiff = diff;
- rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
+ rspamd_mempool_set_variable (task->task_pool,
+ "parts_distance",
+ pdiff,
+ NULL);
if (threshold2 > 0) {
- if (diff >= MIN (threshold, threshold2) && diff < MAX (threshold, threshold2)) {
+ if (diff >=
+ MIN (threshold,
+ threshold2) && diff < MAX (threshold, threshold2)) {
return TRUE;
}
}
}
}
}
- else if ((p1->is_empty && !p2->is_empty) || (!p1->is_empty && p2->is_empty)) {
+ else if ((p1->is_empty &&
+ !p2->is_empty) || (!p1->is_empty && p2->is_empty)) {
/* Empty and non empty parts are different */
*pdiff = 0;
- rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
+ rspamd_mempool_set_variable (task->task_pool,
+ "parts_distance",
+ pdiff,
+ NULL);
return TRUE;
}
}
else {
- debug_task ("message has too many text parts, so do not try to compare them with each other");
- rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
+ debug_task (
+ "message has too many text parts, so do not try to compare them with each other");
+ rspamd_mempool_set_variable (task->task_pool,
+ "parts_distance",
+ pdiff,
+ NULL);
return FALSE;
}
- rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
+ rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff,
+ NULL);
return FALSE;
}
struct addr_list {
- const gchar *name;
- const gchar *addr;
+ const gchar *name;
+ const gchar *addr;
};
#define COMPARE_RCPT_LEN 3
#define MIN_RCPT_TO_COMPARE 7
gboolean
-rspamd_recipients_distance (struct rspamd_task *task, GList * args, void *unused)
+rspamd_recipients_distance (struct rspamd_task *task, GList * args,
+ void *unused)
{
- struct expression_argument *arg;
- InternetAddressList *cur;
- InternetAddress *addr;
- double threshold;
- struct addr_list *ar;
- gchar *c;
- gint num, i, j, hits = 0, total = 0;
+ struct expression_argument *arg;
+ InternetAddressList *cur;
+ InternetAddress *addr;
+ double threshold;
+ struct addr_list *ar;
+ gchar *c;
+ gint num, i, j, hits = 0, total = 0;
if (args == NULL) {
msg_warn ("no parameters to function");
errno = 0;
threshold = strtod ((gchar *)arg->data, NULL);
if (errno != 0) {
- msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
+ msg_warn ("invalid numeric value '%s': %s",
+ (gchar *)arg->data,
+ strerror (errno));
return FALSE;
}
if (num < MIN_RCPT_TO_COMPARE) {
return FALSE;
}
- ar = rspamd_mempool_alloc0 (task->task_pool, num * sizeof (struct addr_list));
+ ar =
+ rspamd_mempool_alloc0 (task->task_pool, num *
+ sizeof (struct addr_list));
/* Fill array */
cur = task->rcpts;
#ifdef GMIME24
- for (i = 0; i < num; i ++) {
+ for (i = 0; i < num; i++) {
addr = internet_address_list_get_address (cur, i);
- ar[i].name = rspamd_mempool_strdup (task->task_pool, internet_address_get_name (addr));
+ ar[i].name = rspamd_mempool_strdup (task->task_pool,
+ internet_address_get_name (addr));
if (ar[i].name != NULL && (c = strchr (ar[i].name, '@')) != NULL) {
*c = '\0';
ar[i].addr = c + 1;
while (cur) {
addr = internet_address_list_get_address (cur);
if (addr && internet_address_get_type (addr) == INTERNET_ADDRESS_NAME) {
- ar[i].name = rspamd_mempool_strdup (task->task_pool, internet_address_get_addr (addr));
+ ar[i].name = rspamd_mempool_strdup (task->task_pool,
+ internet_address_get_addr (addr));
if (ar[i].name != NULL && (c = strchr (ar[i].name, '@')) != NULL) {
*c = '\0';
ar[i].addr = c + 1;
/* Cycle all elements in array */
for (i = 0; i < num; i++) {
for (j = i + 1; j < num; j++) {
- if (ar[i].name && ar[j].name && g_ascii_strncasecmp (ar[i].name, ar[j].name, COMPARE_RCPT_LEN) == 0) {
+ if (ar[i].name && ar[j].name &&
+ g_ascii_strncasecmp (ar[i].name, ar[j].name,
+ COMPARE_RCPT_LEN) == 0) {
/* Common name part */
hits++;
}
- else if (ar[i].addr && ar[j].addr && g_ascii_strcasecmp (ar[i].addr, ar[j].addr) == 0) {
+ else if (ar[i].addr && ar[j].addr &&
+ g_ascii_strcasecmp (ar[i].addr, ar[j].addr) == 0) {
/* Common address part, but different name */
hits++;
}
}
gboolean
-rspamd_has_only_html_part (struct rspamd_task * task, GList * args, void *unused)
+rspamd_has_only_html_part (struct rspamd_task * task, GList * args,
+ void *unused)
{
- struct mime_text_part *p;
- GList *cur;
- gboolean res = FALSE;
+ struct mime_text_part *p;
+ GList *cur;
+ gboolean res = FALSE;
cur = g_list_first (task->text_parts);
while (cur) {
return res;
}
-static gboolean
+static gboolean
is_recipient_list_sorted (const InternetAddressList * ia)
{
- const InternetAddressList *cur;
- InternetAddress *addr;
- gboolean res = TRUE;
- struct addr_list current = { NULL, NULL }, previous = {
- NULL, NULL};
+ const InternetAddressList *cur;
+ InternetAddress *addr;
+ gboolean res = TRUE;
+ struct addr_list current = { NULL, NULL }, previous = {
+ NULL, NULL
+ };
#ifdef GMIME24
- gint num, i;
+ gint num, i;
#endif
/* Do not check to short address lists */
- if (internet_address_list_length ((InternetAddressList *)ia) < MIN_RCPT_TO_COMPARE) {
+ if (internet_address_list_length ((InternetAddressList *)ia) <
+ MIN_RCPT_TO_COMPARE) {
return FALSE;
}
#ifdef GMIME24
num = internet_address_list_length ((InternetAddressList *)ia);
cur = ia;
- for (i = 0; i < num; i ++) {
- addr = internet_address_list_get_address ((InternetAddressList *)cur, i);
+ for (i = 0; i < num; i++) {
+ addr =
+ internet_address_list_get_address ((InternetAddressList *)cur, i);
current.addr = (gchar *)internet_address_get_name (addr);
if (previous.addr != NULL) {
- if (current.addr && g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
+ if (current.addr &&
+ g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
res = FALSE;
break;
}
if (internet_address_get_type (addr) == INTERNET_ADDRESS_NAME) {
current.addr = internet_address_get_addr (addr);
if (previous.addr != NULL) {
- if (current.addr && g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
+ if (current.addr &&
+ g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
res = FALSE;
break;
}
}
gboolean
-rspamd_is_recipients_sorted (struct rspamd_task * task, GList * args, void *unused)
+rspamd_is_recipients_sorted (struct rspamd_task * task,
+ GList * args,
+ void *unused)
{
/* Check all types of addresses */
- if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message, GMIME_RECIPIENT_TYPE_TO)) == TRUE) {
+ if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
+ GMIME_RECIPIENT_TYPE_TO)) == TRUE) {
return TRUE;
}
- if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message, GMIME_RECIPIENT_TYPE_BCC)) == TRUE) {
+ if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
+ GMIME_RECIPIENT_TYPE_BCC)) == TRUE) {
return TRUE;
}
- if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message, GMIME_RECIPIENT_TYPE_CC)) == TRUE) {
+ if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
+ GMIME_RECIPIENT_TYPE_CC)) == TRUE) {
return TRUE;
}
}
gboolean
-rspamd_compare_transfer_encoding (struct rspamd_task * task, GList * args, void *unused)
+rspamd_compare_transfer_encoding (struct rspamd_task * task,
+ GList * args,
+ void *unused)
{
- GMimeObject *part;
+ GMimeObject *part;
#ifndef GMIME24
- GMimePartEncodingType enc_req, part_enc;
+ GMimePartEncodingType enc_req, part_enc;
#else
- GMimeContentEncoding enc_req, part_enc;
+ GMimeContentEncoding enc_req, part_enc;
#endif
- struct expression_argument *arg;
+ struct expression_argument *arg;
if (args == NULL) {
msg_warn ("no parameters to function");
#endif
- debug_task ("got encoding in part: %d and compare with %d", (gint)part_enc, (gint)enc_req);
+ debug_task ("got encoding in part: %d and compare with %d",
+ (gint)part_enc,
+ (gint)enc_req);
#ifndef GMIME24
g_object_unref (part);
#endif
gboolean
rspamd_is_html_balanced (struct rspamd_task * task, GList * args, void *unused)
{
- struct mime_text_part *p;
- GList *cur;
- gboolean res = TRUE;
+ struct mime_text_part *p;
+ GList *cur;
+ gboolean res = TRUE;
cur = g_list_first (task->text_parts);
while (cur) {
}
struct html_callback_data {
- struct html_tag *tag;
- gboolean *res;
+ struct html_tag *tag;
+ gboolean *res;
};
-static gboolean
+static gboolean
search_html_node_callback (GNode * node, gpointer data)
{
- struct html_callback_data *cd = data;
- struct html_node *nd;
+ struct html_callback_data *cd = data;
+ struct html_node *nd;
nd = node->data;
if (nd) {
gboolean
rspamd_has_html_tag (struct rspamd_task * task, GList * args, void *unused)
{
- struct mime_text_part *p;
- GList *cur;
- struct expression_argument *arg;
- struct html_tag *tag;
- gboolean res = FALSE;
- struct html_callback_data cd;
+ struct mime_text_part *p;
+ GList *cur;
+ struct expression_argument *arg;
+ struct html_tag *tag;
+ gboolean res = FALSE;
+ struct html_callback_data cd;
if (args == NULL) {
msg_warn ("no parameters to function");
arg = get_function_arg (args->data, task, TRUE);
tag = get_tag_by_name (arg->data);
if (tag == NULL) {
- msg_warn ("unknown tag type passed as argument: %s", (gchar *)arg->data);
+ msg_warn ("unknown tag type passed as argument: %s",
+ (gchar *)arg->data);
return FALSE;
}
while (cur && res == FALSE) {
p = cur->data;
if (!p->is_empty && p->is_html && p->html_nodes) {
- g_node_traverse (p->html_nodes, G_PRE_ORDER, G_TRAVERSE_ALL, -1, search_html_node_callback, &cd);
+ g_node_traverse (p->html_nodes,
+ G_PRE_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ search_html_node_callback,
+ &cd);
}
cur = g_list_next (cur);
}
gboolean
rspamd_has_fake_html (struct rspamd_task * task, GList * args, void *unused)
{
- struct mime_text_part *p;
- GList *cur;
- gboolean res = FALSE;
+ struct mime_text_part *p;
+ GList *cur;
+ gboolean res = FALSE;
cur = g_list_first (task->text_parts);
* Rspamd expression function
*/
struct expression_function {
- gchar *name; /**< name of function */
- GList *args; /**< its args */
+ gchar *name; /**< name of function */
+ GList *args; /**< its args */
};
/**
EXPRESSION_ARGUMENT_NORMAL,
EXPRESSION_ARGUMENT_BOOL,
EXPRESSION_ARGUMENT_EXPR,
- } type; /**< type of argument (text or other function) */
- void *data; /**< pointer to its data */
+ } type; /**< type of argument (text or other function) */
+ void *data; /**< pointer to its data */
};
-/**
- * Logic expression
+/**
+ * Logic expression
*/
struct expression {
- enum {
+ enum {
EXPR_REGEXP,
- EXPR_OPERATION,
- EXPR_FUNCTION,
- EXPR_STR,
+ EXPR_OPERATION,
+ EXPR_FUNCTION,
+ EXPR_STR,
EXPR_REGEXP_PARSED,
- } type; /**< expression type */
+ } type; /**< expression type */
union {
void *operand;
gchar operation;
- } content; /**< union for storing operand or operation code */
- const gchar *orig; /**< original line */
- struct expression *next; /**< chain link */
+ } content; /**< union for storing operand or operation code */
+ const gchar *orig; /**< original line */
+ struct expression *next; /**< chain link */
};
-typedef gboolean (*rspamd_internal_func_t)(struct rspamd_task *, GList *args, void *user_data);
+typedef gboolean (*rspamd_internal_func_t)(struct rspamd_task *, GList *args,
+ void *user_data);
/**
* Parse regexp line to regexp structure
* @param line incoming line
* @return regexp structure or NULL in case of error
*/
-struct rspamd_regexp* parse_regexp (rspamd_mempool_t *pool, const gchar *line, gboolean raw_mode);
+struct rspamd_regexp * parse_regexp (rspamd_mempool_t *pool,
+ const gchar *line,
+ gboolean raw_mode);
/**
* Parse composites line to composites structure (eg. "SYMBOL1&SYMBOL2|!SYMBOL3")
* @param line incoming line
* @return expression structure or NULL in case of error
*/
-struct expression* parse_expression (rspamd_mempool_t *pool, gchar *line);
+struct expression * parse_expression (rspamd_mempool_t *pool, gchar *line);
/**
* Call specified fucntion and return boolean result
* @param L lua specific state
* @return TRUE or FALSE depending on function result
*/
-gboolean call_expression_function (struct expression_function *func, struct rspamd_task *task, lua_State *L);
+gboolean call_expression_function (struct expression_function *func,
+ struct rspamd_task *task,
+ lua_State *L);
/**
* Register specified function to rspamd internal functions list
* @param name name of function
* @param func pointer to function
*/
-void register_expression_function (const gchar *name, rspamd_internal_func_t func, void *user_data);
+void register_expression_function (const gchar *name,
+ rspamd_internal_func_t func,
+ void *user_data);
/**
* Add regexp to regexp cache
* @param pointer regexp data
* @param result numeric result of this regexp
*/
-void task_cache_add (struct rspamd_task *task, struct rspamd_regexp *re, gint32 result);
+void task_cache_add (struct rspamd_task *task,
+ struct rspamd_regexp *re,
+ gint32 result);
/**
* Check regexp in cache
* @param want_string return NULL if argument is not a string
* @return expression argument structure or NULL if failed
*/
-struct expression_argument *get_function_arg (struct expression *expr, struct rspamd_task *task, gboolean want_string);
+struct expression_argument * get_function_arg (struct expression *expr,
+ struct rspamd_task *task,
+ gboolean want_string);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "binlog.h"
+#include "cfg_file.h"
+#include "classifiers/classifiers.h"
#include "config.h"
-#include "mem_pool.h"
+#include "diff.h"
+#include "expressions.h"
#include "filter.h"
#include "main.h"
+#include "mem_pool.h"
#include "message.h"
-#include "cfg_file.h"
-#include "util.h"
-#include "expressions.h"
-#include "binlog.h"
-#include "diff.h"
-#include "classifiers/classifiers.h"
#include "tokenizers/tokenizers.h"
+#include "util.h"
#ifdef WITH_LUA
# include "lua/lua_common.h"
#ifndef PARAM_H_HAS_BITSET
/* Bit map related macros. */
#define NBBY 8 /* number of bits in a byte */
-#define setbit(a,i) (((unsigned char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
-#define clrbit(a,i) (((unsigned char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
+#define setbit(a, \
+ i) (((unsigned char *)(a))[(i) / NBBY] |= 1 << ((i) % NBBY))
+#define clrbit(a, \
+ i) (((unsigned char *)(a))[(i) / NBBY] &= ~(1 << ((i) % NBBY)))
#define isset(a,i) \
- (((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
+ (((const unsigned char *)(a))[(i) / NBBY] & (1 << ((i) % NBBY)))
#define isclr(a,i) \
- ((((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
+ ((((const unsigned char *)(a))[(i) / NBBY] & (1 << ((i) % NBBY))) == 0)
#endif
-#define BITSPERBYTE (8*sizeof (gchar))
-#define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
+#define BITSPERBYTE (8 * sizeof (gchar))
+#define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
-static inline GQuark
+static inline GQuark
filter_error_quark (void)
{
return g_quark_from_static_string ("g-filter-error-quark");
}
static void
-insert_metric_result (struct rspamd_task *task, struct metric *metric, const gchar *symbol,
- double flag, GList * opts, gboolean single)
+insert_metric_result (struct rspamd_task *task,
+ struct metric *metric,
+ const gchar *symbol,
+ double flag,
+ GList * opts,
+ gboolean single)
{
- struct metric_result *metric_res;
- struct symbol *s;
- gdouble *weight, w;
+ struct metric_result *metric_res;
+ struct symbol *s;
+ gdouble *weight, w;
metric_res = g_hash_table_lookup (task->results, metric->name);
if (metric_res == NULL) {
/* Create new metric chain */
- metric_res = rspamd_mempool_alloc (task->task_pool, sizeof (struct metric_result));
- metric_res->symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ metric_res =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct metric_result));
+ metric_res->symbols = g_hash_table_new (rspamd_str_hash,
+ rspamd_str_equal);
metric_res->checked = FALSE;
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_hash_table_unref, metric_res->symbols);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_unref,
+ metric_res->symbols);
metric_res->metric = metric;
metric_res->grow_factor = 0;
metric_res->score = 0;
- g_hash_table_insert (task->results, (gpointer) metric->name, metric_res);
+ g_hash_table_insert (task->results, (gpointer) metric->name,
+ metric_res);
}
-
+
weight = g_hash_table_lookup (metric->symbols, symbol);
if (weight == NULL) {
w = 0.0;
if ((s = g_hash_table_lookup (metric_res->symbols, symbol)) != NULL) {
if (s->options && opts && opts != s->options) {
/* Append new options */
- s->options = g_list_concat (s->options, g_list_copy(opts));
+ s->options = g_list_concat (s->options, g_list_copy (opts));
/*
* Note that there is no need to add new destructor of GList as elements of appended
* GList are used directly, so just free initial GList
}
else if (opts) {
s->options = g_list_copy (opts);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_list_free, s->options);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_list_free, s->options);
}
if (!single) {
/* Handle grow factor */
if (opts) {
s->options = g_list_copy (opts);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_list_free, s->options);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_list_free, s->options);
}
else {
s->options = NULL;
g_hash_table_insert (metric_res->symbols, (gpointer) symbol, s);
}
- debug_task ("symbol %s, score %.2f, metric %s, factor: %f", symbol, s->score, metric->name, w);
-
+ debug_task ("symbol %s, score %.2f, metric %s, factor: %f",
+ symbol,
+ s->score,
+ metric->name,
+ w);
+
}
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
-static GStaticMutex result_mtx = G_STATIC_MUTEX_INIT;
+static GStaticMutex result_mtx = G_STATIC_MUTEX_INIT;
#else
G_LOCK_DEFINE (result_mtx);
#endif
static void
-insert_result_common (struct rspamd_task *task, const gchar *symbol, double flag, GList * opts, gboolean single)
+insert_result_common (struct rspamd_task *task,
+ const gchar *symbol,
+ double flag,
+ GList * opts,
+ gboolean single)
{
- struct metric *metric;
- struct cache_item *item;
- GList *cur, *metric_list;
+ struct metric *metric;
+ struct cache_item *item;
+ GList *cur, *metric_list;
/* Avoid concurrenting inserting of results */
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
metric_list = g_hash_table_lookup (task->cfg->metrics_symbols, symbol);
if (metric_list) {
cur = metric_list;
-
+
while (cur) {
metric = cur->data;
insert_metric_result (task, metric, symbol, flag, opts, single);
}
else {
/* Insert symbol to default metric */
- insert_metric_result (task, task->cfg->default_metric, symbol, flag, opts, single);
+ insert_metric_result (task,
+ task->cfg->default_metric,
+ symbol,
+ flag,
+ opts,
+ single);
}
/* Process cache item */
/* Insert result that may be increased on next insertions */
void
-insert_result (struct rspamd_task *task, const gchar *symbol, double flag, GList * opts)
+insert_result (struct rspamd_task *task,
+ const gchar *symbol,
+ double flag,
+ GList * opts)
{
insert_result_common (task, symbol, flag, opts, task->cfg->one_shot_mode);
}
/* Insert result as a single option */
void
-insert_result_single (struct rspamd_task *task, const gchar *symbol, double flag, GList * opts)
+insert_result_single (struct rspamd_task *task,
+ const gchar *symbol,
+ double flag,
+ GList * opts)
{
insert_result_common (task, symbol, flag, opts, TRUE);
}
static gboolean
check_metric_settings (struct rspamd_task *task, struct metric *metric,
- double *score)
+ double *score)
{
const ucl_object_t *mobj, *reject;
double val;
}
/* Return true if metric has score that is more than spam score for it */
-static gboolean
+static gboolean
check_metric_is_spam (struct rspamd_task *task, struct metric *metric)
{
- struct metric_result *res;
- double ms;
+ struct metric_result *res;
+ double ms;
/* Avoid concurrency while checking results */
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
gint
process_filters (struct rspamd_task *task)
{
- GList *cur;
- struct metric *metric;
- gpointer item = NULL;
+ GList *cur;
+ struct metric *metric;
+ gpointer item = NULL;
/* Process metrics symbols */
while (call_symbol_callback (task, task->cfg->cache, &item)) {
while (cur) {
metric = cur->data;
if (!task->pass_all_filters &&
- metric->actions[METRIC_ACTION_REJECT].score > 0 &&
- check_metric_is_spam (task, metric)) {
+ metric->actions[METRIC_ACTION_REJECT].score > 0 &&
+ check_metric_is_spam (task, metric)) {
task->state = WRITE_REPLY;
return 1;
}
struct composites_data {
- struct rspamd_task *task;
- struct metric_result *metric_res;
- GTree *symbols_to_remove;
- guint8 *checked;
+ struct rspamd_task *task;
+ struct metric_result *metric_res;
+ GTree *symbols_to_remove;
+ guint8 *checked;
};
struct symbol_remove_data {
- struct symbol *ms;
- gboolean remove_weight;
- gboolean remove_symbol;
+ struct symbol *ms;
+ gboolean remove_weight;
+ gboolean remove_symbol;
};
static gint
remove_compare_data (gconstpointer a, gconstpointer b)
{
- const gchar *ca = a, *cb = b;
+ const gchar *ca = a, *cb = b;
return strcmp (ca, cb);
}
static void
composites_foreach_callback (gpointer key, gpointer value, void *data)
{
- struct composites_data *cd = (struct composites_data *)data;
- struct rspamd_composite *composite = value, *ncomp;
- struct expression *expr;
- GQueue *stack;
- GList *symbols = NULL, *s;
- gsize cur, op1, op2;
- gchar logbuf[256], *sym, *check_sym;
- gint r;
- struct symbol *ms;
- struct symbol_remove_data *rd;
+ struct composites_data *cd = (struct composites_data *)data;
+ struct rspamd_composite *composite = value, *ncomp;
+ struct expression *expr;
+ GQueue *stack;
+ GList *symbols = NULL, *s;
+ gsize cur, op1, op2;
+ gchar logbuf[256], *sym, *check_sym;
+ gint r;
+ struct symbol *ms;
+ struct symbol_remove_data *rd;
expr = composite->expr;
/* Find corresponding symbol */
sym = expr->content.operand;
if (*sym == '~' || *sym == '-') {
- sym ++;
+ sym++;
}
if (g_hash_table_lookup (cd->metric_res->symbols, sym) == NULL) {
cur = 0;
- if ((ncomp = g_hash_table_lookup (cd->task->cfg->composite_symbols, sym)) != NULL) {
+ if ((ncomp =
+ g_hash_table_lookup (cd->task->cfg->composite_symbols,
+ sym)) != NULL) {
/* Set checked for this symbol to avoid cyclic references */
if (isclr (cd->checked, ncomp->id)) {
setbit (cd->checked, composite->id);
composites_foreach_callback (sym, ncomp, cd);
- if (g_hash_table_lookup (cd->metric_res->symbols, sym) != NULL) {
+ if (g_hash_table_lookup (cd->metric_res->symbols,
+ sym) != NULL) {
cur = 1;
}
}
if (op1) {
/* Remove all symbols that are in composite symbol */
s = g_list_first (symbols);
- r = rspamd_snprintf (logbuf, sizeof (logbuf), "<%s>, insert symbol %s instead of symbols: ", cd->task->message_id, key);
+ r = rspamd_snprintf (logbuf,
+ sizeof (logbuf),
+ "<%s>, insert symbol %s instead of symbols: ",
+ cd->task->message_id,
+ key);
while (s) {
sym = s->data;
if (*sym == '~' || *sym == '-') {
if (ms == NULL) {
/* Try to process other composites */
- if ((ncomp = g_hash_table_lookup (cd->task->cfg->composite_symbols, check_sym)) != NULL) {
+ if ((ncomp =
+ g_hash_table_lookup (cd->task->cfg->composite_symbols,
+ check_sym)) != NULL) {
/* Set checked for this symbol to avoid cyclic references */
if (isclr (cd->checked, ncomp->id)) {
setbit (cd->checked, composite->id);
composites_foreach_callback (check_sym, ncomp, cd);
- ms = g_hash_table_lookup (cd->metric_res->symbols, check_sym);
+ ms = g_hash_table_lookup (cd->metric_res->symbols,
+ check_sym);
}
}
}
if (ms != NULL) {
- rd = rspamd_mempool_alloc (cd->task->task_pool, sizeof (struct symbol_remove_data));
+ rd =
+ rspamd_mempool_alloc (cd->task->task_pool,
+ sizeof (struct symbol_remove_data));
rd->ms = ms;
if (G_UNLIKELY (*sym == '~')) {
rd->remove_weight = FALSE;
rd->remove_weight = TRUE;
}
if (!g_tree_lookup (cd->symbols_to_remove, rd)) {
- g_tree_insert (cd->symbols_to_remove, (gpointer)ms->name, rd);
+ g_tree_insert (cd->symbols_to_remove,
+ (gpointer)ms->name,
+ rd);
}
}
else {
}
if (s->next) {
- r += rspamd_snprintf (logbuf + r, sizeof (logbuf) -r, "%s, ", s->data);
+ r += rspamd_snprintf (logbuf + r,
+ sizeof (logbuf) - r,
+ "%s, ",
+ s->data);
}
else {
- r += rspamd_snprintf (logbuf + r, sizeof (logbuf) -r, "%s", s->data);
+ r += rspamd_snprintf (logbuf + r,
+ sizeof (logbuf) - r,
+ "%s",
+ s->data);
}
s = g_list_next (s);
}
return;
}
-static gboolean
-check_autolearn (struct statfile_autolearn_params *params, struct rspamd_task *task)
+static gboolean
+check_autolearn (struct statfile_autolearn_params *params,
+ struct rspamd_task *task)
{
- gchar *metric_name = DEFAULT_METRIC;
- struct metric_result *metric_res;
- GList *cur;
+ gchar *metric_name = DEFAULT_METRIC;
+ struct metric_result *metric_res;
+ GList *cur;
if (params->metric != NULL) {
metric_name = (gchar *)params->metric;
}
else {
/* Process score of metric */
- if ((params->threshold_min != 0 && metric_res->score > params->threshold_min) || (params->threshold_max != 0 && metric_res->score < params->threshold_max)) {
+ if ((params->threshold_min != 0 && metric_res->score >
+ params->threshold_min) ||
+ (params->threshold_max != 0 && metric_res->score <
+ params->threshold_max)) {
/* Now check for specific symbols */
if (params->symbols) {
cur = params->symbols;
while (cur) {
- if (g_hash_table_lookup (metric_res->symbols, cur->data) == NULL) {
+ if (g_hash_table_lookup (metric_res->symbols,
+ cur->data) == NULL) {
return FALSE;
}
cur = g_list_next (cur);
}
void
-process_autolearn (struct rspamd_statfile_config *st, struct rspamd_task *task, GTree * tokens, struct classifier *classifier, gchar *filename, struct classifier_ctx *ctx)
+process_autolearn (struct rspamd_statfile_config *st,
+ struct rspamd_task *task,
+ GTree * tokens,
+ struct classifier *classifier,
+ gchar *filename,
+ struct classifier_ctx *ctx)
{
- stat_file_t *statfile;
- struct rspamd_statfile_config *unused;
+ stat_file_t *statfile;
+ struct rspamd_statfile_config *unused;
if (check_autolearn (st->autolearn, task)) {
if (tokens) {
/* Take care of subject */
tokenize_subject (task, &tokens);
- msg_info ("message with id <%s> autolearned statfile '%s'", task->message_id, filename);
-
+ msg_info ("message with id <%s> autolearned statfile '%s'",
+ task->message_id,
+ filename);
+
/* Get or create statfile */
- statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool, ctx->cfg,
- st->symbol, &unused, TRUE);
-
+ statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool,
+ ctx->cfg,
+ st->symbol,
+ &unused,
+ TRUE);
+
if (statfile == NULL) {
return;
}
- classifier->learn_func (ctx, task->worker->srv->statfile_pool, st->symbol, tokens, TRUE, NULL, 1., NULL);
+ classifier->learn_func (ctx,
+ task->worker->srv->statfile_pool,
+ st->symbol,
+ tokens,
+ TRUE,
+ NULL,
+ 1.,
+ NULL);
maybe_write_binlog (ctx->cfg, st, statfile, tokens);
- statfile_pool_plan_invalidate (task->worker->srv->statfile_pool, DEFAULT_STATFILE_INVALIDATE_TIME, DEFAULT_STATFILE_INVALIDATE_JITTER);
+ statfile_pool_plan_invalidate (task->worker->srv->statfile_pool,
+ DEFAULT_STATFILE_INVALIDATE_TIME,
+ DEFAULT_STATFILE_INVALIDATE_JITTER);
}
}
}
static gboolean
composites_remove_symbols (gpointer key, gpointer value, gpointer data)
{
- struct composites_data *cd = data;
- struct symbol_remove_data *rd = value;
+ struct composites_data *cd = data;
+ struct symbol_remove_data *rd = value;
if (rd->remove_symbol) {
g_hash_table_remove (cd->metric_res->symbols, key);
static void
composites_metric_callback (gpointer key, gpointer value, gpointer data)
{
- struct rspamd_task *task = (struct rspamd_task *)data;
- struct composites_data *cd = rspamd_mempool_alloc (task->task_pool, sizeof (struct composites_data));
- struct metric_result *metric_res = (struct metric_result *)value;
+ struct rspamd_task *task = (struct rspamd_task *)data;
+ struct composites_data *cd =
+ rspamd_mempool_alloc (task->task_pool, sizeof (struct composites_data));
+ struct metric_result *metric_res = (struct metric_result *)value;
cd->task = task;
cd->metric_res = (struct metric_result *)metric_res;
cd->symbols_to_remove = g_tree_new (remove_compare_data);
- cd->checked = rspamd_mempool_alloc0 (task->task_pool, NBYTES (g_hash_table_size (task->cfg->composite_symbols)));
+ cd->checked =
+ rspamd_mempool_alloc0 (task->task_pool,
+ NBYTES (g_hash_table_size (task->cfg->composite_symbols)));
/* Process hash table */
- g_hash_table_foreach (task->cfg->composite_symbols, composites_foreach_callback, cd);
+ g_hash_table_foreach (task->cfg->composite_symbols,
+ composites_foreach_callback,
+ cd);
/* Remove symbols that are in composites */
g_tree_foreach (cd->symbols_to_remove, composites_remove_symbols, cd);
static void
classifiers_callback (gpointer value, void *arg)
{
- struct classifiers_cbdata *cbdata = arg;
- struct rspamd_task *task;
- struct rspamd_classifier_config *cl = value;
- struct classifier_ctx *ctx;
- struct mime_text_part *text_part, *p1, *p2;
- struct rspamd_statfile_config *st;
- GTree *tokens = NULL;
- GList *cur;
- f_str_t c;
- gchar *header = NULL;
- gint *dist = NULL, diff;
- gboolean is_twopart = FALSE;
-
+ struct classifiers_cbdata *cbdata = arg;
+ struct rspamd_task *task;
+ struct rspamd_classifier_config *cl = value;
+ struct classifier_ctx *ctx;
+ struct mime_text_part *text_part, *p1, *p2;
+ struct rspamd_statfile_config *st;
+ GTree *tokens = NULL;
+ GList *cur;
+ f_str_t c;
+ gchar *header = NULL;
+ gint *dist = NULL, diff;
+ gboolean is_twopart = FALSE;
+
task = cbdata->task;
if ((header = g_hash_table_lookup (cl->opts, "header")) != NULL) {
- cur = message_get_header (task->task_pool, task->message, header, FALSE);
+ cur =
+ message_get_header (task->task_pool, task->message, header, FALSE);
if (cur) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, cur);
}
}
else {
cur = g_list_first (task->text_parts);
- dist = rspamd_mempool_get_variable (task->task_pool, "parts_distance");
+ dist = rspamd_mempool_get_variable (task->task_pool, "parts_distance");
if (cur != NULL && cur->next != NULL && cur->next->next == NULL) {
is_twopart = TRUE;
}
c.len = strlen (cur->data);
if (c.len > 0) {
c.begin = cur->data;
- if (!cl->tokenizer->tokenize_func (cl->tokenizer, task->task_pool, &c, &tokens, FALSE, FALSE, NULL)) {
+ if (!cl->tokenizer->tokenize_func (cl->tokenizer,
+ task->task_pool, &c, &tokens, FALSE, FALSE, NULL)) {
msg_info ("cannot tokenize input");
return;
}
/* Compare part's content */
if (*dist >= COMMON_PART_FACTOR) {
- msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
+ msg_info (
+ "message <%s> has two common text parts, ignore the last one",
+ task->message_id);
break;
}
}
p1 = cur->prev->data;
p2 = text_part;
if (p1->diff_str != NULL && p2->diff_str != NULL) {
- diff = compare_diff_distance (p1->diff_str, p2->diff_str);
+ diff =
+ compare_diff_distance (p1->diff_str, p2->diff_str);
}
else {
diff = fuzzy_compare_parts (p1, p2);
}
if (diff >= COMMON_PART_FACTOR) {
- msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
+ msg_info (
+ "message <%s> has two common text parts, ignore the last one",
+ task->message_id);
break;
}
}
c.begin = (gchar *)text_part->content->data;
c.len = text_part->content->len;
/* Tree would be freed at task pool freeing */
- if (!cl->tokenizer->tokenize_func (cl->tokenizer, task->task_pool, &c, &tokens,
- FALSE, text_part->is_utf, text_part->urls_offset)) {
+ if (!cl->tokenizer->tokenize_func (cl->tokenizer,
+ task->task_pool, &c, &tokens,
+ FALSE, text_part->is_utf, text_part->urls_offset)) {
msg_info ("cannot tokenize input");
return;
}
if (cbdata->nL != NULL) {
rspamd_mutex_lock (cbdata->nL->m);
- cl->classifier->classify_func (ctx, task->worker->srv->statfile_pool, tokens, task, cbdata->nL->L);
+ cl->classifier->classify_func (ctx,
+ task->worker->srv->statfile_pool,
+ tokens,
+ task,
+ cbdata->nL->L);
rspamd_mutex_unlock (cbdata->nL->m);
}
else {
/* Non-threaded case */
- cl->classifier->classify_func (ctx, task->worker->srv->statfile_pool, tokens, task, task->cfg->lua_state);
+ cl->classifier->classify_func (ctx,
+ task->worker->srv->statfile_pool,
+ tokens,
+ task,
+ task->cfg->lua_state);
}
/* Autolearning */
if (st->autolearn) {
if (check_autolearn (st->autolearn, task)) {
/* Process autolearn */
- process_autolearn (st, task, tokens, cl->classifier, st->path, ctx);
+ process_autolearn (st,
+ task,
+ tokens,
+ cl->classifier,
+ st->path,
+ ctx);
}
}
cur = g_list_next (cur);
void
process_statfiles (struct rspamd_task *task)
{
- struct classifiers_cbdata cbdata;
+ struct classifiers_cbdata cbdata;
if (task->is_skipped) {
return;
if (task->tokens == NULL) {
task->tokens = g_hash_table_new (g_direct_hash, g_direct_equal);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
}
cbdata.task = task;
cbdata.nL = NULL;
void
process_statfiles_threaded (gpointer data, gpointer user_data)
{
- struct rspamd_task *task = (struct rspamd_task *)data;
- struct lua_locked_state *nL = user_data;
- struct classifiers_cbdata cbdata;
+ struct rspamd_task *task = (struct rspamd_task *)data;
+ struct lua_locked_state *nL = user_data;
+ struct classifiers_cbdata cbdata;
if (task->is_skipped) {
remove_async_thread (task->s);
if (task->tokens == NULL) {
task->tokens = g_hash_table_new (g_direct_hash, g_direct_equal);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
}
cbdata.task = task;
}
static void
-insert_metric_header (gpointer metric_name, gpointer metric_value, gpointer data)
+insert_metric_header (gpointer metric_name, gpointer metric_value,
+ gpointer data)
{
#ifndef GLIB_HASH_COMPAT
- struct rspamd_task *task = (struct rspamd_task *)data;
- gint r = 0;
+ struct rspamd_task *task = (struct rspamd_task *)data;
+ gint r = 0;
/* Try to be rfc2822 compatible and avoid long headers with folding */
- gchar header_name[128], outbuf[1000];
- GList *symbols = NULL, *cur;
- struct metric_result *metric_res = (struct metric_result *)metric_value;
- double ms;
+ gchar header_name[128], outbuf[1000];
+ GList *symbols = NULL, *cur;
+ struct metric_result *metric_res = (struct metric_result *)metric_value;
+ double ms;
- rspamd_snprintf (header_name, sizeof (header_name), "X-Spam-%s", metric_res->metric->name);
+ rspamd_snprintf (header_name,
+ sizeof (header_name),
+ "X-Spam-%s",
+ metric_res->metric->name);
if (!check_metric_settings (task, metric_res->metric, &ms)) {
ms = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
}
g_list_free (symbols);
#ifdef GMIME24
- g_mime_object_append_header (GMIME_OBJECT (task->message), header_name, outbuf);
+ g_mime_object_append_header (GMIME_OBJECT (
+ task->message), header_name, outbuf);
#else
g_mime_message_add_header (task->message, header_name, outbuf);
#endif
if (g_ascii_strncasecmp (data, "reject", sizeof ("reject") - 1) == 0) {
*result = METRIC_ACTION_REJECT;
}
- else if (g_ascii_strncasecmp (data, "greylist", sizeof ("greylist") - 1) == 0) {
+ else if (g_ascii_strncasecmp (data, "greylist",
+ sizeof ("greylist") - 1) == 0) {
*result = METRIC_ACTION_GREYLIST;
}
- else if (g_ascii_strncasecmp (data, "add_header", sizeof ("add_header") - 1) == 0) {
+ else if (g_ascii_strncasecmp (data, "add_header", sizeof ("add_header") -
+ 1) == 0) {
*result = METRIC_ACTION_ADD_HEADER;
}
- else if (g_ascii_strncasecmp (data, "rewrite_subject", sizeof ("rewrite_subject") - 1) == 0) {
+ else if (g_ascii_strncasecmp (data, "rewrite_subject",
+ sizeof ("rewrite_subject") - 1) == 0) {
*result = METRIC_ACTION_REWRITE_SUBJECT;
}
else {
gint
check_metric_action (double score, double required_score, struct metric *metric)
{
- struct metric_action *action, *selected_action = NULL;
- double max_score = 0;
- int i;
+ struct metric_action *action, *selected_action = NULL;
+ double max_score = 0;
+ int i;
if (score >= required_score) {
return METRIC_ACTION_REJECT;
return METRIC_ACTION_NOACTION;
}
else {
- for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
+ for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
action = &metric->actions[i];
if (action->score < 0) {
continue;
gboolean
learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
{
- GList *cur, *ex;
- struct rspamd_classifier_config *cl;
- struct classifier_ctx *cls_ctx;
- gchar *s;
- f_str_t c;
- GTree *tokens = NULL;
- struct rspamd_statfile_config *st;
- stat_file_t *stf;
- gdouble sum;
- struct mime_text_part *part, *p1, *p2;
- gboolean is_utf = FALSE, is_twopart = FALSE;
- gint diff;
+ GList *cur, *ex;
+ struct rspamd_classifier_config *cl;
+ struct classifier_ctx *cls_ctx;
+ gchar *s;
+ f_str_t c;
+ GTree *tokens = NULL;
+ struct rspamd_statfile_config *st;
+ stat_file_t *stf;
+ gdouble sum;
+ struct mime_text_part *part, *p1, *p2;
+ gboolean is_utf = FALSE, is_twopart = FALSE;
+ gint diff;
/* Load classifier by symbol */
cl = g_hash_table_lookup (task->cfg->classifiers_symbols, statfile);
if (cl == NULL) {
- g_set_error (err, filter_error_quark(), 1, "Statfile %s is not configured in any classifier", statfile);
+ g_set_error (err,
+ filter_error_quark (), 1, "Statfile %s is not configured in any classifier",
+ statfile);
return FALSE;
}
if ((s = g_hash_table_lookup (cl->opts, "header")) != NULL) {
cur = message_get_header (task->task_pool, task->message, s, FALSE);
if (cur) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, cur);
}
}
else {
diff = fuzzy_compare_parts (p1, p2);
}
if (diff >= COMMON_PART_FACTOR) {
- msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
+ msg_info (
+ "message <%s> has two common text parts, ignore the last one",
+ task->message_id);
break;
}
}
if (!cl->tokenizer->tokenize_func (
cl->tokenizer, task->task_pool,
&c, &tokens, FALSE, is_utf, ex)) {
- g_set_error (err, filter_error_quark(), 2, "Cannot tokenize message");
+ g_set_error (err,
+ filter_error_quark (), 2, "Cannot tokenize message");
return FALSE;
}
cur = g_list_next (cur);
/* Handle messages without text */
if (tokens == NULL) {
- g_set_error (err, filter_error_quark(), 3, "Cannot tokenize message, no text data");
- msg_info ("learn failed for message <%s>, no tokens to extract", task->message_id);
+ g_set_error (err,
+ filter_error_quark (), 3, "Cannot tokenize message, no text data");
+ msg_info ("learn failed for message <%s>, no tokens to extract",
+ task->message_id);
return FALSE;
}
/* Init classifier */
cls_ctx = cl->classifier->init_func (
- task->task_pool, cl);
+ task->task_pool, cl);
/* Get or create statfile */
stf = get_statfile_by_symbol (task->worker->srv->statfile_pool,
cl, statfile, &st, TRUE);
statfile, tokens, TRUE, &sum,
1.0, err)) {
if (*err) {
- msg_info ("learn failed for message <%s>, learn error: %s", task->message_id, (*err)->message);
+ msg_info ("learn failed for message <%s>, learn error: %s",
+ task->message_id,
+ (*err)->message);
return FALSE;
}
else {
- g_set_error (err, filter_error_quark(), 4, "Learn failed, unknown learn classifier error");
- msg_info ("learn failed for message <%s>, unknown learn error", task->message_id);
+ g_set_error (err,
+ filter_error_quark (), 4,
+ "Learn failed, unknown learn classifier error");
+ msg_info ("learn failed for message <%s>, unknown learn error",
+ task->message_id);
return FALSE;
}
}
task->worker->srv->stat->messages_learned++;
maybe_write_binlog (cl, st, stf, tokens);
- msg_info ("learn success for message <%s>, for statfile: %s, sum weight: %.2f",
- task->message_id, statfile, sum);
+ msg_info (
+ "learn success for message <%s>, for statfile: %s, sum weight: %.2f",
+ task->message_id,
+ statfile,
+ sum);
statfile_pool_plan_invalidate (task->worker->srv->statfile_pool,
- DEFAULT_STATFILE_INVALIDATE_TIME,
- DEFAULT_STATFILE_INVALIDATE_JITTER);
+ DEFAULT_STATFILE_INVALIDATE_TIME,
+ DEFAULT_STATFILE_INVALIDATE_JITTER);
return TRUE;
}
gboolean
-learn_task_spam (struct rspamd_classifier_config *cl, struct rspamd_task *task, gboolean is_spam, GError **err)
+learn_task_spam (struct rspamd_classifier_config *cl,
+ struct rspamd_task *task,
+ gboolean is_spam,
+ GError **err)
{
- GList *cur, *ex;
- struct classifier_ctx *cls_ctx;
- f_str_t c;
- GTree *tokens = NULL;
- struct mime_text_part *part, *p1, *p2;
- gboolean is_utf = FALSE, is_twopart = FALSE;
- gint diff;
+ GList *cur, *ex;
+ struct classifier_ctx *cls_ctx;
+ f_str_t c;
+ GTree *tokens = NULL;
+ struct mime_text_part *part, *p1, *p2;
+ gboolean is_utf = FALSE, is_twopart = FALSE;
+ gint diff;
cur = g_list_first (task->text_parts);
if (cur != NULL && cur->next != NULL && cur->next->next == NULL) {
diff = fuzzy_compare_parts (p1, p2);
}
if (diff >= COMMON_PART_FACTOR) {
- msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
+ msg_info (
+ "message <%s> has two common text parts, ignore the last one",
+ task->message_id);
break;
}
}
if (!cl->tokenizer->tokenize_func (
cl->tokenizer, task->task_pool,
&c, &tokens, FALSE, is_utf, ex)) {
- g_set_error (err, filter_error_quark(), 2, "Cannot tokenize message");
+ g_set_error (err,
+ filter_error_quark (), 2, "Cannot tokenize message");
return FALSE;
}
cur = g_list_next (cur);
/* Handle messages without text */
if (tokens == NULL) {
- g_set_error (err, filter_error_quark(), 3, "Cannot tokenize message, no text data");
- msg_info ("learn failed for message <%s>, no tokens to extract", task->message_id);
+ g_set_error (err,
+ filter_error_quark (), 3, "Cannot tokenize message, no text data");
+ msg_info ("learn failed for message <%s>, no tokens to extract",
+ task->message_id);
return FALSE;
}
/* Init classifier */
cls_ctx = cl->classifier->init_func (
- task->task_pool, cl);
+ task->task_pool, cl);
/* Learn */
if (!cl->classifier->learn_spam_func (
cls_ctx, task->worker->srv->statfile_pool,
tokens, task, is_spam, task->cfg->lua_state, err)) {
if (*err) {
- msg_info ("learn failed for message <%s>, learn error: %s", task->message_id, (*err)->message);
+ msg_info ("learn failed for message <%s>, learn error: %s",
+ task->message_id,
+ (*err)->message);
return FALSE;
}
else {
- g_set_error (err, filter_error_quark(), 4, "Learn failed, unknown learn classifier error");
- msg_info ("learn failed for message <%s>, unknown learn error", task->message_id);
+ g_set_error (err,
+ filter_error_quark (), 4,
+ "Learn failed, unknown learn classifier error");
+ msg_info ("learn failed for message <%s>, unknown learn error",
+ task->message_id);
return FALSE;
}
}
task->worker->srv->stat->messages_learned++;
msg_info ("learn success for message <%s>",
- task->message_id);
+ task->message_id);
statfile_pool_plan_invalidate (task->worker->srv->statfile_pool,
- DEFAULT_STATFILE_INVALIDATE_TIME,
- DEFAULT_STATFILE_INVALIDATE_JITTER);
+ DEFAULT_STATFILE_INVALIDATE_TIME,
+ DEFAULT_STATFILE_INVALIDATE_JITTER);
return TRUE;
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
struct rspamd_settings;
struct rspamd_classifier_config;
-typedef double (*metric_cons_func)(struct rspamd_task *task, const gchar *metric_name, const gchar *func_name);
+typedef double (*metric_cons_func)(struct rspamd_task *task,
+ const gchar *metric_name, const gchar *func_name);
typedef void (*filter_func)(struct rspamd_task *task);
enum filter_type { C_FILTER, PERL_FILTER };
* Filter structure
*/
struct filter {
- gchar *func_name; /**< function name */
- enum filter_type type; /**< filter type (c or perl) */
- module_t *module;
+ gchar *func_name; /**< function name */
+ enum filter_type type; /**< filter type (c or perl) */
+ module_t *module;
};
/**
* Rspamd symbol
*/
struct symbol {
- double score; /**< symbol's score */
- GList *options; /**< list of symbol's options */
+ double score; /**< symbol's score */
+ GList *options; /**< list of symbol's options */
const gchar *name;
};
* Common definition of metric
*/
struct metric {
- const gchar *name; /**< name of metric */
- gchar *func_name; /**< name of consolidation function */
- metric_cons_func func; /**< c consolidation function */
- double grow_factor; /**< grow factor for metric */
- GHashTable *symbols; /**< weights of symbols in metric */
- GHashTable *descriptions; /**< descriptions of symbols in metric */
+ const gchar *name; /**< name of metric */
+ gchar *func_name; /**< name of consolidation function */
+ metric_cons_func func; /**< c consolidation function */
+ double grow_factor; /**< grow factor for metric */
+ GHashTable *symbols; /**< weights of symbols in metric */
+ GHashTable *descriptions; /**< descriptions of symbols in metric */
struct metric_action actions[METRIC_ACTION_MAX]; /**< all actions of the metric */
- gchar *subject; /**< subject rewrite string */
+ gchar *subject; /**< subject rewrite string */
};
/**
* Result of metric processing
*/
struct metric_result {
- struct metric *metric; /**< pointer to metric structure */
- double score; /**< total score */
- GHashTable *symbols; /**< symbols of metric */
- gboolean checked; /**< whether metric result is consolidated */
- double grow_factor; /**< current grow factor */
+ struct metric *metric; /**< pointer to metric structure */
+ double score; /**< total score */
+ GHashTable *symbols; /**< symbols of metric */
+ gboolean checked; /**< whether metric result is consolidated */
+ double grow_factor; /**< current grow factor */
};
/**
* @param flag numeric weight for symbol
* @param opts list of symbol's options
*/
-void insert_result (struct rspamd_task *task, const gchar *symbol, double flag, GList *opts);
+void insert_result (struct rspamd_task *task,
+ const gchar *symbol,
+ double flag,
+ GList *opts);
/**
* Insert a single result to task
* @param flag numeric weight for symbol
* @param opts list of symbol's options
*/
-void insert_result_single (struct rspamd_task *task, const gchar *symbol, double flag, GList *opts);
+void insert_result_single (struct rspamd_task *task,
+ const gchar *symbol,
+ double flag,
+ GList *opts);
/**
* Process all results and form composite metrics from existent metrics as it is defined in config
void make_composites (struct rspamd_task *task);
/**
- * Default consolidation function for metric, it get all symbols and multiply symbol
+ * Default consolidation function for metric, it get all symbols and multiply symbol
* weight by some factor that is specified in config. Default factor is 1.
* @param task worker's task that present message from user
* @param metric_name name of metric
* @return result metric weight
*/
-double factor_consolidation_func (struct rspamd_task *task, const gchar *metric_name, const gchar *unused);
+double factor_consolidation_func (struct rspamd_task *task,
+ const gchar *metric_name,
+ const gchar *unused);
/*
* Learn specified statfile with message in a task
* @param err pointer to GError
* @return true if learn succeed
*/
-gboolean learn_task (const gchar *statfile, struct rspamd_task *task, GError **err);
+gboolean learn_task (const gchar *statfile,
+ struct rspamd_task *task,
+ GError **err);
/*
* Learn specified statfile with message in a task
* @param err pointer to GError
* @return true if learn succeed
*/
-gboolean learn_task_spam (struct rspamd_classifier_config *cl, struct rspamd_task *task, gboolean is_spam, GError **err);
+gboolean learn_task_spam (struct rspamd_classifier_config *cl,
+ struct rspamd_task *task,
+ gboolean is_spam,
+ GError **err);
/*
* Get action from a string
/*
* Return textual representation of action enumeration
*/
-const gchar *str_action_metric (enum rspamd_metric_action action);
+const gchar * str_action_metric (enum rspamd_metric_action action);
/*
* Get action for specific metric
*/
-gint check_metric_action (double score, double required_score, struct metric *metric);
+gint check_metric_action (double score,
+ double required_score,
+ struct metric *metric);
#endif
static const guint8 gif_signature[] = {'G', 'I', 'F', '8'};
static const guint8 bmp_signature[] = {'B', 'M'};
-static void process_image (struct rspamd_task *task, struct mime_part *part);
+static void process_image (struct rspamd_task *task, struct mime_part *part);
void
process_images (struct rspamd_task *task)
{
- GList *cur;
- struct mime_part *part;
+ GList *cur;
+ struct mime_part *part;
cur = task->parts;
while (cur) {
part = cur->data;
- if (g_mime_content_type_is_type (part->type, "image", "*") && part->content->len > 0) {
+ if (g_mime_content_type_is_type (part->type, "image",
+ "*") && part->content->len > 0) {
process_image (task, part);
}
cur = g_list_next (cur);
static struct rspamd_image *
process_png_image (struct rspamd_task *task, GByteArray *data)
{
- struct rspamd_image *img;
- guint32 t;
- guint8 *p;
+ struct rspamd_image *img;
+ guint32 t;
+ guint8 *p;
if (data->len < 24) {
msg_info ("bad png detected (maybe striped): <%s>", task->message_id);
static struct rspamd_image *
process_jpg_image (struct rspamd_task *task, GByteArray *data)
{
- guint8 *p;
- guint16 t;
- gsize remain;
- struct rspamd_image *img;
+ guint8 *p;
+ guint16 t;
+ gsize remain;
+ struct rspamd_image *img;
img = rspamd_mempool_alloc (task->task_pool, sizeof (struct rspamd_image));
img->type = IMAGE_TYPE_JPG;
p = data->data;
remain = data->len;
/* In jpeg we should find any data stream (ff c0 .. ff c3) and extract its height and width */
- while (remain --) {
- if (*p == 0xFF && remain > 8 && (*(p + 1) >= 0xC0 && *(p + 1) <= 0xC3)) {
+ while (remain--) {
+ if (*p == 0xFF && remain > 8 &&
+ (*(p + 1) >= 0xC0 && *(p + 1) <= 0xC3)) {
memcpy (&t, p + 5, sizeof (guint16));
img->height = ntohs (t);
memcpy (&t, p + 7, sizeof (guint16));
img->width = ntohs (t);
return img;
}
- p ++;
+ p++;
}
return NULL;
static struct rspamd_image *
process_gif_image (struct rspamd_task *task, GByteArray *data)
{
- struct rspamd_image *img;
- guint8 *p;
- guint16 t;
+ struct rspamd_image *img;
+ guint8 *p;
+ guint16 t;
if (data->len < 10) {
msg_info ("bad gif detected (maybe striped): <%s>", task->message_id);
img->data = data;
p = data->data + 6;
- memcpy (&t, p, sizeof (guint16));
+ memcpy (&t, p, sizeof (guint16));
img->width = GUINT16_FROM_LE (t);
memcpy (&t, p + 2, sizeof (guint16));
img->height = GUINT16_FROM_LE (t);
static struct rspamd_image *
process_bmp_image (struct rspamd_task *task, GByteArray *data)
{
- struct rspamd_image *img;
- gint32 t;
- guint8 *p;
+ struct rspamd_image *img;
+ gint32 t;
+ guint8 *p;
img->type = IMAGE_TYPE_BMP;
img->data = data;
p = data->data + 18;
- memcpy (&t, p, sizeof (gint32));
+ memcpy (&t, p, sizeof (gint32));
img->width = abs (GINT32_FROM_LE (t));
memcpy (&t, p + 4, sizeof (gint32));
img->height = abs (GINT32_FROM_LE (t));
static void
process_image (struct rspamd_task *task, struct mime_part *part)
{
- enum known_image_types type;
- struct rspamd_image *img = NULL;
+ enum known_image_types type;
+ struct rspamd_image *img = NULL;
if ((type = detect_image_type (part->content)) != IMAGE_TYPE_UNKNOWN) {
switch (type) {
case IMAGE_TYPE_PNG:
if (img != NULL) {
debug_task ("detected %s image of size %ud x %ud in message <%s>",
- image_type_str (img->type),
- img->width, img->height,
- task->message_id);
+ image_type_str (img->type),
+ img->width, img->height,
+ task->message_id);
img->filename = part->filename;
task->images = g_list_prepend (task->images, img);
}
/*
* Get textual representation of an image's type
*/
-const gchar *image_type_str (enum known_image_types type);
+const gchar * image_type_str (enum known_image_types type);
#endif /* IMAGES_H_ */
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
-#include "util.h"
-#include "main.h"
-#include "message.h"
#include "cfg_file.h"
+#include "config.h"
#include "html.h"
#include "images.h"
+#include "main.h"
+#include "message.h"
+#include "util.h"
#define RECURSION_LIMIT 30
#define UTF8_CHARSET "UTF-8"
-GByteArray *
-strip_html_tags (struct rspamd_task *task, rspamd_mempool_t * pool, struct mime_text_part *part, GByteArray * src, gint *stateptr)
+GByteArray *
+strip_html_tags (struct rspamd_task *task,
+ rspamd_mempool_t * pool,
+ struct mime_text_part *part,
+ GByteArray * src,
+ gint *stateptr)
{
- uint8_t *p, *rp, *tbegin = NULL, *end, c, lc;
- gint br, i = 0, depth = 0, in_q = 0;
- gint state = 0;
- GByteArray *buf;
- GNode *level_ptr = NULL;
- gboolean erase = FALSE;
+ uint8_t *p, *rp, *tbegin = NULL, *end, c, lc;
+ gint br, i = 0, depth = 0, in_q = 0;
+ gint state = 0;
+ GByteArray *buf;
+ GNode *level_ptr = NULL;
+ gboolean erase = FALSE;
if (stateptr)
state = *stateptr;
}
else if (state == 1) {
/* Opening bracket without closing one */
- p --;
+ p--;
while (g_ascii_isspace (*p) && p > src->data) {
- p --;
+ p--;
}
- p ++;
+ p++;
goto unbreak_tag;
}
break;
}
unbreak_tag:
switch (state) {
- case 1: /* HTML/XML */
+ case 1: /* HTML/XML */
lc = '>';
in_q = state = 0;
- erase = !add_html_node (task, pool, part, tbegin, p - tbegin, end - tbegin, &level_ptr);
+ erase = !add_html_node (task,
+ pool,
+ part,
+ tbegin,
+ p - tbegin,
+ end - tbegin,
+ &level_ptr);
break;
- case 2: /* PHP */
+ case 2: /* PHP */
if (!br && lc != '\"' && *(p - 1) == '?') {
in_q = state = 0;
}
in_q = state = 0;
break;
- case 4: /* JavaScript/CSS/etc... */
+ case 4: /* JavaScript/CSS/etc... */
if (p >= src->data + 2 && *(p - 1) == '-' && *(p - 2) == '-') {
in_q = state = 0;
}
else if (state == 0 && !erase) {
*(rp++) = c;
}
- if (state && p != src->data && *(p - 1) != '\\' && (!in_q || *p == in_q)) {
+ if (state && p != src->data && *(p - 1) != '\\' &&
+ (!in_q || *p == in_q)) {
if (in_q) {
in_q = 0;
}
break;
case '-':
- if (state == 3 && p >= src->data + 2 && *(p - 1) == '-' && *(p - 2) == '!') {
+ if (state == 3 && p >= src->data + 2 && *(p - 1) == '-' &&
+ *(p - 2) == '!') {
state = 4;
}
else {
if (state == 3 && p > src->data + 6
&& g_ascii_tolower (*(p - 1)) == 'p'
&& g_ascii_tolower (*(p - 2)) == 'y'
- && g_ascii_tolower (*(p - 3)) == 't' && g_ascii_tolower (*(p - 4)) == 'c' && g_ascii_tolower (*(p - 5)) == 'o' && g_ascii_tolower (*(p - 6)) == 'd') {
+ && g_ascii_tolower (*(p - 3)) == 't' &&
+ g_ascii_tolower (*(p - 4)) == 'c' &&
+ g_ascii_tolower (*(p - 5)) == 'o' &&
+ g_ascii_tolower (*(p - 6)) == 'd') {
state = 1;
break;
}
- /* fall-through */
+ /* fall-through */
case 'l':
* state == 2 (PHP). Switch back to HTML.
*/
- if (state == 2 && p > src->data + 2 && *(p - 1) == 'm' && *(p - 2) == 'x') {
+ if (state == 2 && p > src->data + 2 && *(p - 1) == 'm' &&
+ *(p - 2) == 'x') {
state = 1;
break;
}
- /* fall-through */
+ /* fall-through */
default:
- reg_char:
+reg_char:
if (state == 0 && !erase) {
*(rp++) = c;
}
}
static void
-parse_qmail_recv (rspamd_mempool_t * pool, gchar *line, struct received_header *r)
+parse_qmail_recv (rspamd_mempool_t * pool,
+ gchar *line,
+ struct received_header *r)
{
- gchar *s, *p, t;
+ gchar *s, *p, t;
/* We are interested only with received from network headers */
if ((p = strstr (line, "from network")) == NULL) {
/* format is ip/host */
s = p;
if (*p) {
- while (g_ascii_isdigit (*++p) || *p == '.');
+ while (g_ascii_isdigit (*++p) || *p == '.') ;
if (*p != '/') {
r->is_error = 1;
return;
*p = '/';
/* Now try to parse hostname */
s = ++p;
- while (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p == '_') {
+ while (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p ==
+ '_') {
p++;
}
t = *p;
}
static void
-parse_recv_header (rspamd_mempool_t * pool, gchar *line, struct received_header *r)
+parse_recv_header (rspamd_mempool_t * pool,
+ gchar *line,
+ struct received_header *r)
{
- gchar *p, *s, t, **res = NULL;
+ gchar *p, *s, t, **res = NULL;
enum {
RSPAMD_RECV_STATE_INIT = 0,
RSPAMD_RECV_STATE_FROM,
RSPAMD_RECV_STATE_SKIP_SPACES,
RSPAMD_RECV_STATE_ERROR
} state = RSPAMD_RECV_STATE_INIT,
- next_state = RSPAMD_RECV_STATE_INIT;
- gboolean is_exim = FALSE;
+ next_state = RSPAMD_RECV_STATE_INIT;
+ gboolean is_exim = FALSE;
g_strstrip (line);
p = line;
while (*p) {
switch (state) {
- /* Initial state, search for from */
+ /* Initial state, search for from */
case RSPAMD_RECV_STATE_INIT:
if (*p == 'f' || *p == 'F') {
- if (g_ascii_tolower (*++p) == 'r' && g_ascii_tolower (*++p) == 'o' && g_ascii_tolower (*++p) == 'm') {
+ if (g_ascii_tolower (*++p) == 'r' && g_ascii_tolower (*++p) ==
+ 'o' && g_ascii_tolower (*++p) == 'm') {
p++;
state = RSPAMD_RECV_STATE_SKIP_SPACES;
next_state = RSPAMD_RECV_STATE_FROM;
}
}
- else if (g_ascii_tolower (*p) == 'b' && g_ascii_tolower (*(p + 1)) == 'y') {
+ else if (g_ascii_tolower (*p) == 'b' &&
+ g_ascii_tolower (*(p + 1)) == 'y') {
state = RSPAMD_RECV_STATE_IP_BLOCK;
}
else {
return;
}
break;
- /* Read hostname */
+ /* Read hostname */
case RSPAMD_RECV_STATE_FROM:
if (*p == '[') {
/* This should be IP address */
next_state = RSPAMD_RECV_STATE_IP_BLOCK;
s = ++p;
}
- else if (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p == '_') {
+ else if (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p ==
+ '_') {
p++;
}
else {
next_state = RSPAMD_RECV_STATE_IP_BLOCK;
}
break;
- /* Try to extract additional info */
+ /* Try to extract additional info */
case RSPAMD_RECV_STATE_IP_BLOCK:
/* Try to extract ip or () info or by */
- if (g_ascii_tolower (*p) == 'b' && g_ascii_tolower (*(p + 1)) == 'y') {
+ if (g_ascii_tolower (*p) == 'b' && g_ascii_tolower (*(p + 1)) ==
+ 'y') {
p += 2;
/* Skip spaces after by */
state = RSPAMD_RECV_STATE_SKIP_SPACES;
p++;
}
break;
- /* We are in () block. Here can be found real hostname and real ip, this is written by some MTA */
+ /* We are in () block. Here can be found real hostname and real ip, this is written by some MTA */
case RSPAMD_RECV_STATE_BRACES_BLOCK:
/* End of block */
if (g_ascii_isalnum (*p) || *p == '.' || *p == '-' ||
- *p == '_' || *p == ':') {
+ *p == '_' || *p == ':') {
p++;
}
else if (*p == '[') {
next_state = RSPAMD_RECV_STATE_BRACES_BLOCK;
}
else if (p - s == 4 && memcmp (s, "helo=", 5) == 0) {
- p ++;
+ p++;
is_exim = TRUE;
- if (r->real_hostname == NULL && r->from_hostname != NULL) {
+ if (r->real_hostname == NULL && r->from_hostname !=
+ NULL) {
r->real_hostname = r->from_hostname;
}
s = p;
- while (*p != ')' && !g_ascii_isspace (*p) && *p != '\0') {
- p ++;
+ while (*p != ')' && !g_ascii_isspace (*p) && *p !=
+ '\0') {
+ p++;
}
if (p > s) {
- r->from_hostname = rspamd_mempool_alloc (pool, p - s + 1);
+ r->from_hostname = rspamd_mempool_alloc (pool,
+ p - s + 1);
rspamd_strlcpy (r->from_hostname, s, p - s + 1);
}
}
else if (p - s == 4 && memcmp (s, "port=", 5) == 0) {
- p ++;
+ p++;
is_exim = TRUE;
while (g_ascii_isdigit (*p)) {
- p ++;
+ p++;
}
state = RSPAMD_RECV_STATE_SKIP_SPACES;
next_state = RSPAMD_RECV_STATE_BRACES_BLOCK;
}
else if (*p == '=' && is_exim) {
/* Just skip unknown pairs */
- p ++;
- while (!g_ascii_isspace (*p) && *p != ')' && *p != '\0') {
- p ++;
+ p++;
+ while (!g_ascii_isspace (*p) && *p != ')' && *p !=
+ '\0') {
+ p++;
}
state = RSPAMD_RECV_STATE_SKIP_SPACES;
next_state = RSPAMD_RECV_STATE_BRACES_BLOCK;
}
else {
/* skip all */
- while (*p++ != ')' && *p != '\0');
+ while (*p++ != ')' && *p != '\0') ;
state = RSPAMD_RECV_STATE_IP_BLOCK;
}
}
continue;
}
if (*p == ')') {
- p ++;
+ p++;
state = RSPAMD_RECV_STATE_SKIP_SPACES;
next_state = RSPAMD_RECV_STATE_IP_BLOCK;
}
}
else if (*p == ')') {
- p ++;
+ p++;
state = RSPAMD_RECV_STATE_SKIP_SPACES;
next_state = RSPAMD_RECV_STATE_IP_BLOCK;
}
}
}
break;
- /* Got by word */
+ /* Got by word */
case RSPAMD_RECV_STATE_BY_BLOCK:
/* Here can be only hostname */
if ((g_ascii_isalnum (*p) || *p == '.' || *p == '-'
- || *p == '_') && p[1] != '\0') {
+ || *p == '_') && p[1] != '\0') {
p++;
}
else {
}
else if (r->from_ip == NULL && r->real_ip != NULL) {
r->from_ip = r->real_ip;
- if (r->real_hostname == NULL && r->from_hostname != NULL) {
+ if (r->real_hostname == NULL && r->from_hostname !=
+ NULL) {
r->real_hostname = r->from_hostname;
}
}
}
break;
- /* Extract ip */
+ /* Extract ip */
case RSPAMD_RECV_STATE_PARSE_IP:
while (g_ascii_isxdigit (*p) || *p == '.' || *p == ':') {
- p ++;
+ p++;
}
if (*p != ']') {
/* Not an ip in fact */
}
break;
- /* Skip spaces */
+ /* Skip spaces */
case RSPAMD_RECV_STATE_SKIP_SPACES:
if (!g_ascii_isspace (*p)) {
state = next_state;
static void
process_raw_headers (struct rspamd_task *task)
{
- struct raw_header *new = NULL, *lp;
- gchar *p, *c, *tmp, *tp;
- gint state = 0, l, next_state = 100, err_state = 100, t_state;
- gboolean valid_folding = FALSE;
+ struct raw_header *new = NULL, *lp;
+ gchar *p, *c, *tmp, *tp;
+ gint state = 0, l, next_state = 100, err_state = 100, t_state;
+ gboolean valid_folding = FALSE;
p = task->raw_headers_str;
c = p;
case 1:
/* We got something like header's name */
if (*p == ':') {
- new = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct raw_header));
+ new =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct raw_header));
l = p - c;
tmp = rspamd_mempool_alloc (task->task_pool, l + 1);
rspamd_strlcpy (tmp, c, l + 1);
new->name = tmp;
new->empty_separator = TRUE;
- p ++;
+ p++;
state = 2;
c = p;
}
next_state = 0;
}
else {
- p ++;
+ p++;
}
break;
case 2:
if (*p == '\t') {
new->tab_separated = TRUE;
new->empty_separator = FALSE;
- p ++;
+ p++;
}
else if (*p == ' ') {
new->empty_separator = FALSE;
- p ++;
+ p++;
}
else if (*p == '\n' || *p == '\r') {
/* Process folding */
state = 4;
}
else {
- p ++;
+ p++;
}
break;
case 4:
tmp = rspamd_mempool_alloc (task->task_pool, l + 1);
tp = tmp;
t_state = 0;
- while (l --) {
+ while (l--) {
if (t_state == 0) {
/* Before folding */
if (*c == '\n' || *c == '\r') {
t_state = 1;
- c ++;
- *tp ++ = ' ';
+ c++;
+ *tp++ = ' ';
}
else {
- *tp ++ = *c ++;
+ *tp++ = *c++;
}
}
else if (t_state == 1) {
}
else {
t_state = 0;
- *tp ++ = *c ++;
+ *tp++ = *c++;
}
}
}
/* Strip last space that can be added by \r\n parsing */
if (*(tp - 1) == ' ') {
- tp --;
+ tp--;
}
*tp = '\0';
new->value = tmp;
new->next = NULL;
- if ((lp = g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
+ if ((lp =
+ g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
while (lp->next != NULL) {
lp = lp->next;
}
/* Header has only name, no value */
new->next = NULL;
new->value = "";
- if ((lp = g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
+ if ((lp =
+ g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
while (lp->next != NULL) {
lp = lp->next;
}
}
else {
if (*p == '\r' || *p == '\n') {
- p ++;
+ p++;
valid_folding = FALSE;
}
else if (*p == '\t' || *p == ' ') {
/* Valid folding */
- p ++;
+ p++;
valid_folding = TRUE;
}
else {
/* Fail state, skip line */
if (*p == '\r') {
if (*(p + 1) == '\n') {
- p ++;
+ p++;
}
- p ++;
+ p++;
state = next_state;
}
else if (*p == '\n') {
if (*(p + 1) == '\r') {
- p ++;
+ p++;
}
- p ++;
+ p++;
state = next_state;
}
else if (*(p + 1) == '\0') {
state = next_state;
- p ++;
+ p++;
}
else {
- p ++;
+ p++;
}
break;
}
static void
free_byte_array_callback (void *pointer)
{
- GByteArray *arr = (GByteArray *) pointer;
+ GByteArray *arr = (GByteArray *) pointer;
g_byte_array_free (arr, TRUE);
}
-static GByteArray *
-convert_text_to_utf (struct rspamd_task *task, GByteArray * part_content, GMimeContentType * type, struct mime_text_part *text_part)
+static GByteArray *
+convert_text_to_utf (struct rspamd_task *task,
+ GByteArray * part_content,
+ GMimeContentType * type,
+ struct mime_text_part *text_part)
{
- GError *err = NULL;
- gsize read_bytes, write_bytes;
- const gchar *charset;
- gchar *res_str;
- GByteArray *result_array;
+ GError *err = NULL;
+ gsize read_bytes, write_bytes;
+ const gchar *charset;
+ gchar *res_str;
+ GByteArray *result_array;
if (task->cfg->raw_mode) {
text_part->is_raw = TRUE;
return part_content;
}
- if ((charset = g_mime_content_type_get_parameter (type, "charset")) == NULL) {
+ if ((charset =
+ g_mime_content_type_get_parameter (type, "charset")) == NULL) {
text_part->is_raw = TRUE;
return part_content;
}
- if (g_ascii_strcasecmp (charset, "utf-8") == 0 || g_ascii_strcasecmp (charset, "utf8") == 0) {
+ if (g_ascii_strcasecmp (charset,
+ "utf-8") == 0 || g_ascii_strcasecmp (charset, "utf8") == 0) {
if (g_utf8_validate (part_content->data, part_content->len, NULL)) {
text_part->is_raw = FALSE;
text_part->is_utf = TRUE;
return part_content;
}
else {
- msg_info ("<%s>: contains invalid utf8 characters, assume it as raw", task->message_id);
+ msg_info (
+ "<%s>: contains invalid utf8 characters, assume it as raw",
+ task->message_id);
text_part->is_raw = TRUE;
return part_content;
}
}
- res_str = g_convert_with_fallback (part_content->data, part_content->len, UTF8_CHARSET, charset, NULL, &read_bytes, &write_bytes, &err);
+ res_str = g_convert_with_fallback (part_content->data,
+ part_content->len,
+ UTF8_CHARSET,
+ charset,
+ NULL,
+ &read_bytes,
+ &write_bytes,
+ &err);
if (res_str == NULL) {
- msg_warn ("<%s>: cannot convert from %s to utf8: %s", task->message_id, charset, err ? err->message : "unknown problem");
+ msg_warn ("<%s>: cannot convert from %s to utf8: %s",
+ task->message_id,
+ charset,
+ err ? err->message : "unknown problem");
text_part->is_raw = TRUE;
return part_content;
}
result_array = rspamd_mempool_alloc (task->task_pool, sizeof (GByteArray));
result_array->data = res_str;
result_array->len = write_bytes;
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_free, res_str);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_free,
+ res_str);
text_part->is_raw = FALSE;
text_part->is_utf = TRUE;
}
static void
-process_text_part (struct rspamd_task *task, GByteArray *part_content, GMimeContentType *type,
- GMimeObject *part, GMimeObject *parent, gboolean is_empty)
+process_text_part (struct rspamd_task *task,
+ GByteArray *part_content,
+ GMimeContentType *type,
+ GMimeObject *part,
+ GMimeObject *parent,
+ gboolean is_empty)
{
- struct mime_text_part *text_part;
- const gchar *cd;
+ struct mime_text_part *text_part;
+ const gchar *cd;
/* Skip attachements */
#ifndef GMIME24
cd = g_mime_part_get_content_disposition (GMIME_PART (part));
- if (cd && g_ascii_strcasecmp (cd, "attachment") == 0 && !task->cfg->check_text_attachements) {
+ if (cd &&
+ g_ascii_strcasecmp (cd,
+ "attachment") == 0 && !task->cfg->check_text_attachements) {
debug_task ("skip attachments for checking as text parts");
return;
}
#else
cd = g_mime_object_get_disposition (GMIME_OBJECT (part));
- if (cd && g_ascii_strcasecmp (cd, GMIME_DISPOSITION_ATTACHMENT) == 0 && !task->cfg->check_text_attachements) {
+ if (cd &&
+ g_ascii_strcasecmp (cd,
+ GMIME_DISPOSITION_ATTACHMENT) == 0 &&
+ !task->cfg->check_text_attachements) {
debug_task ("skip attachments for checking as text parts");
return;
}
#endif
- if (g_mime_content_type_is_type (type, "text", "html") || g_mime_content_type_is_type (type, "text", "xhtml")) {
+ if (g_mime_content_type_is_type (type, "text",
+ "html") || g_mime_content_type_is_type (type, "text", "xhtml")) {
debug_task ("got urls from text/html part");
- text_part = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct mime_text_part));
+ text_part =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct mime_text_part));
text_part->is_html = TRUE;
if (is_empty) {
text_part->is_empty = TRUE;
task->text_parts = g_list_prepend (task->text_parts, text_part);
return;
}
- text_part->orig = convert_text_to_utf (task, part_content, type, text_part);
+ text_part->orig = convert_text_to_utf (task,
+ part_content,
+ type,
+ text_part);
text_part->is_balanced = TRUE;
text_part->html_nodes = NULL;
text_part->parent = parent;
- text_part->content = strip_html_tags (task, task->task_pool, text_part, text_part->orig, NULL);
+ text_part->content = strip_html_tags (task,
+ task->task_pool,
+ text_part,
+ text_part->orig,
+ NULL);
if (text_part->html_nodes == NULL) {
url_parse_text (task->task_pool, task, text_part, FALSE);
}
else {
- decode_entitles (text_part->content->data, &text_part->content->len);
+ decode_entitles (text_part->content->data,
+ &text_part->content->len);
url_parse_text (task->task_pool, task, text_part, FALSE);
#if 0
url_parse_text (task->task_pool, task, text_part, TRUE);
}
fuzzy_init_part (text_part, task->task_pool, task->cfg->max_diff);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) free_byte_array_callback, text_part->content);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) free_byte_array_callback,
+ text_part->content);
task->text_parts = g_list_prepend (task->text_parts, text_part);
}
else if (g_mime_content_type_is_type (type, "text", "*")) {
debug_task ("got urls from text/plain part");
- text_part = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct mime_text_part));
+ text_part =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct mime_text_part));
text_part->is_html = FALSE;
text_part->parent = parent;
if (is_empty) {
task->text_parts = g_list_prepend (task->text_parts, text_part);
return;
}
- text_part->orig = convert_text_to_utf (task, part_content, type, text_part);
+ text_part->orig = convert_text_to_utf (task,
+ part_content,
+ type,
+ text_part);
text_part->content = text_part->orig;
url_parse_text (task->task_pool, task, text_part, FALSE);
fuzzy_init_part (text_part, task->task_pool, task->cfg->max_diff);
#ifdef GMIME24
static void
-mime_foreach_callback (GMimeObject * parent, GMimeObject * part, gpointer user_data)
+mime_foreach_callback (GMimeObject * parent,
+ GMimeObject * part,
+ gpointer user_data)
#else
static void
mime_foreach_callback (GMimeObject * part, gpointer user_data)
#endif
{
- struct rspamd_task *task = (struct rspamd_task *)user_data;
- struct mime_part *mime_part;
- GMimeContentType *type;
- GMimeDataWrapper *wrapper;
- GMimeStream *part_stream;
- GByteArray *part_content;
+ struct rspamd_task *task = (struct rspamd_task *)user_data;
+ struct mime_part *mime_part;
+ GMimeContentType *type;
+ GMimeDataWrapper *wrapper;
+ GMimeStream *part_stream;
+ GByteArray *part_content;
task->parts_count++;
/* find out what class 'part' is... */
if (GMIME_IS_MESSAGE_PART (part)) {
/* message/rfc822 or message/news */
- GMimeMessage *message;
+ GMimeMessage *message;
/* g_mime_message_foreach_part() won't descend into
child message parts, so if we want to count any
else if (GMIME_IS_MULTIPART (part)) {
/* multipart/mixed, multipart/alternative, multipart/related, multipart/signed, multipart/encrypted, etc... */
task->parser_parent_part = part;
-#ifndef GMIME24
+#ifndef GMIME24
debug_task ("detected multipart part");
/* we'll get to finding out if this is a signed/encrypted multipart later... */
if (task->parser_recursion++ < RECURSION_LIMIT) {
- g_mime_multipart_foreach ((GMimeMultipart *) part, mime_foreach_callback, task);
+ g_mime_multipart_foreach ((GMimeMultipart *) part,
+ mime_foreach_callback,
+ task);
}
else {
msg_err ("endless recursion detected: %d", task->parser_recursion);
else if (GMIME_IS_PART (part)) {
/* a normal leaf part, could be text/plain or image/jpeg etc */
#ifdef GMIME24
- type = (GMimeContentType *) g_mime_object_get_content_type (GMIME_OBJECT (part));
+ type = (GMimeContentType *) g_mime_object_get_content_type (GMIME_OBJECT (
+ part));
#else
- type = (GMimeContentType *) g_mime_part_get_content_type (GMIME_PART (part));
+ type =
+ (GMimeContentType *) g_mime_part_get_content_type (GMIME_PART (part));
#endif
if (type == NULL) {
msg_warn ("type of part is unknown, assume text/plain");
type = g_mime_content_type_new ("text", "plain");
#ifdef GMIME24
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, type);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_object_unref, type);
#else
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_mime_content_type_destroy, type);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_mime_content_type_destroy, type);
#endif
}
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper != NULL) {
#endif
part_stream = g_mime_stream_mem_new ();
- if (g_mime_data_wrapper_write_to_stream (wrapper, part_stream) != -1) {
- g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (part_stream), FALSE);
- part_content = g_mime_stream_mem_get_byte_array (GMIME_STREAM_MEM (part_stream));
+ if (g_mime_data_wrapper_write_to_stream (wrapper,
+ part_stream) != -1) {
+ g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (
+ part_stream), FALSE);
+ part_content = g_mime_stream_mem_get_byte_array (GMIME_STREAM_MEM (
+ part_stream));
g_object_unref (part_stream);
- mime_part = rspamd_mempool_alloc (task->task_pool, sizeof (struct mime_part));
+ mime_part =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct mime_part));
mime_part->type = type;
mime_part->content = part_content;
mime_part->parent = task->parser_parent_part;
- mime_part->filename = g_mime_part_get_filename (GMIME_PART (part));
- debug_task ("found part with content-type: %s/%s", type->type, type->subtype);
+ mime_part->filename = g_mime_part_get_filename (GMIME_PART (
+ part));
+ debug_task ("found part with content-type: %s/%s",
+ type->type,
+ type->subtype);
task->parts = g_list_prepend (task->parts, mime_part);
/* Skip empty parts */
- process_text_part (task, part_content, type, part, task->parser_parent_part, (part_content->len <= 0));
+ process_text_part (task,
+ part_content,
+ type,
+ part,
+ task->parser_parent_part,
+ (part_content->len <= 0));
}
else {
- msg_warn ("write to stream failed: %d, %s", errno, strerror (errno));
+ msg_warn ("write to stream failed: %d, %s", errno,
+ strerror (errno));
}
#ifndef GMIME24
g_object_unref (wrapper);
#endif
}
else {
- msg_warn ("cannot get wrapper for mime part, type of part: %s/%s", type->type, type->subtype);
+ msg_warn ("cannot get wrapper for mime part, type of part: %s/%s",
+ type->type,
+ type->subtype);
}
}
else {
static void
destroy_message (void *pointer)
{
- GMimeMessage *msg = pointer;
+ GMimeMessage *msg = pointer;
msg_debug ("freeing pointer %p", msg);
g_object_unref (msg);
gint
process_message (struct rspamd_task *task)
{
- GMimeMessage *message;
- GMimeParser *parser;
- GMimeStream *stream;
- GByteArray *tmp;
- GList *first, *cur;
- GMimePart *part;
- GMimeDataWrapper *wrapper;
- struct received_header *recv;
- gchar *mid, *url_str, *p, *end, *url_end;
- struct uri *subject_url;
- gsize len;
- gint rc;
+ GMimeMessage *message;
+ GMimeParser *parser;
+ GMimeStream *stream;
+ GByteArray *tmp;
+ GList *first, *cur;
+ GMimePart *part;
+ GMimeDataWrapper *wrapper;
+ struct received_header *recv;
+ gchar *mid, *url_str, *p, *end, *url_end;
+ struct uri *subject_url;
+ gsize len;
+ gint rc;
tmp = rspamd_mempool_alloc (task->task_pool, sizeof (GByteArray));
tmp->data = task->msg->str;
tmp->len = task->msg->len;
stream = g_mime_stream_mem_new_with_byte_array (tmp);
- /*
- * This causes g_mime_stream not to free memory by itself as it is memory allocated by
- * pool allocator
- */
+ /*
+ * This causes g_mime_stream not to free memory by itself as it is memory allocated by
+ * pool allocator
+ */
g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (stream), FALSE);
if (task->is_mime) {
- debug_task ("construct mime parser from string length %d", (gint)task->msg->len);
+ debug_task ("construct mime parser from string length %d",
+ (gint)task->msg->len);
/* create a new parser object to parse the stream */
parser = g_mime_parser_new_with_stream (stream);
g_object_unref (stream);
}
task->message = message;
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) destroy_message, task->message);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) destroy_message, task->message);
/* Save message id for future use */
task->message_id = g_mime_message_get_message_id (task->message);
}
#ifdef GMIME24
- task->raw_headers_str = g_mime_object_get_headers (GMIME_OBJECT (task->message));
+ task->raw_headers_str =
+ g_mime_object_get_headers (GMIME_OBJECT (task->message));
#else
task->raw_headers_str = g_mime_message_get_headers (task->message);
#endif
process_images (task);
/* Parse received headers */
- first = message_get_header (task->task_pool, message, "Received", FALSE);
+ first =
+ message_get_header (task->task_pool, message, "Received", FALSE);
cur = first;
while (cur) {
- recv = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct received_header));
+ recv =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct received_header));
parse_recv_header (task->task_pool, cur->data, recv);
task->received = g_list_prepend (task->received, recv);
cur = g_list_next (cur);
}
if (task->raw_headers_str) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_free, task->raw_headers_str);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_free, task->raw_headers_str);
process_raw_headers (task);
}
task->rcpts = g_mime_message_get_all_recipients (message);
if (task->rcpts) {
#ifdef GMIME24
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, task->rcpts);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_object_unref,
+ task->rcpts);
#else
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) internet_address_list_destroy, task->rcpts);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) internet_address_list_destroy,
+ task->rcpts);
#endif
}
/* Construct part for it */
part = g_mime_part_new_with_type ("text", "html");
#ifdef GMIME24
- wrapper = g_mime_data_wrapper_new_with_stream (stream, GMIME_CONTENT_ENCODING_8BIT);
+ wrapper = g_mime_data_wrapper_new_with_stream (stream,
+ GMIME_CONTENT_ENCODING_8BIT);
#else
- wrapper = g_mime_data_wrapper_new_with_stream (stream, GMIME_PART_ENCODING_8BIT);
+ wrapper = g_mime_data_wrapper_new_with_stream (stream,
+ GMIME_PART_ENCODING_8BIT);
#endif
g_mime_part_set_content_object (part, wrapper);
g_mime_message_set_mime_part (task->message, GMIME_OBJECT (part));
/* Register destructors */
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, wrapper);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, part);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) destroy_message, task->message);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_object_unref, wrapper);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_object_unref, part);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) destroy_message, task->message);
/* Now parse in a normal way */
task->parser_recursion = 0;
#ifdef GMIME24
g_mime_message_foreach (task->message, mime_foreach_callback, task);
#else
- g_mime_message_foreach_part (task->message, mime_foreach_callback, task);
+ g_mime_message_foreach_part (task->message, mime_foreach_callback,
+ task);
#endif
/* Generate message ID */
mid = g_mime_utils_generate_message_id ("localhost.localdomain");
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_free, mid);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_free, mid);
g_mime_message_set_message_id (task->message, mid);
task->message_id = mid;
task->queue_id = mid;
if (task->rcpt) {
cur = task->rcpt;
while (cur) {
- g_mime_message_add_recipient (task->message, GMIME_RECIPIENT_TYPE_TO, NULL, (gchar *)cur->data);
+ g_mime_message_add_recipient (task->message,
+ GMIME_RECIPIENT_TYPE_TO,
+ NULL,
+ (gchar *)cur->data);
cur = g_list_next (cur);
}
}
while (p < end) {
/* Search to the end of url */
- if (url_try_text (task->task_pool, p, end - p, NULL, &url_end, &url_str, FALSE)) {
+ if (url_try_text (task->task_pool, p, end - p, NULL, &url_end,
+ &url_str, FALSE)) {
if (url_str != NULL) {
- subject_url = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct uri));
+ subject_url = rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct uri));
if (subject_url != NULL) {
/* Try to parse url */
rc = parse_uri (subject_url, url_str, task->task_pool);
- if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc == URI_ERRNO_NO_HOST_SLASH) &&
- subject_url->hostlen > 0) {
+ if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES ||
+ rc == URI_ERRNO_NO_HOST_SLASH) &&
+ subject_url->hostlen > 0) {
if (subject_url->protocol != PROTOCOL_MAILTO) {
if (!g_tree_lookup (task->urls, subject_url)) {
- g_tree_insert (task->urls, subject_url, subject_url);
+ g_tree_insert (task->urls,
+ subject_url,
+ subject_url);
}
}
}
else if (rc != URI_ERRNO_OK) {
- msg_info ("extract of url '%s' failed: %s", url_str, url_strerror (rc));
+ msg_info ("extract of url '%s' failed: %s",
+ url_str,
+ url_strerror (rc));
}
}
}
}
struct gmime_raw_header {
- struct raw_header *next;
- gchar *name;
- gchar *value;
+ struct raw_header *next;
+ gchar *name;
+ gchar *value;
};
typedef struct _GMimeHeader {
- GHashTable *hash;
- GHashTable *writers;
- struct raw_header *headers;
+ GHashTable *hash;
+ GHashTable *writers;
+ struct raw_header *headers;
} local_GMimeHeader;
*/
#ifndef GMIME24
static void
-header_iterate (rspamd_mempool_t * pool, struct gmime_raw_header *h, GList ** ret, const gchar *field, gboolean strong)
+header_iterate (rspamd_mempool_t * pool,
+ struct gmime_raw_header *h,
+ GList ** ret,
+ const gchar *field,
+ gboolean strong)
{
while (h) {
if (G_LIKELY (!strong)) {
- if (h->value && !g_ascii_strncasecmp (field, h->name, strlen (field))) {
+ if (h->value &&
+ !g_ascii_strncasecmp (field, h->name, strlen (field))) {
if (pool != NULL) {
- *ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, h->value));
+ *ret =
+ g_list_prepend (*ret,
+ rspamd_mempool_strdup (pool, h->value));
}
else {
*ret = g_list_prepend (*ret, g_strdup (h->value));
else {
if (h->value && !strncmp (field, h->name, strlen (field))) {
if (pool != NULL) {
- *ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, h->value));
+ *ret =
+ g_list_prepend (*ret,
+ rspamd_mempool_strdup (pool, h->value));
}
else {
*ret = g_list_prepend (*ret, g_strdup (h->value));
}
#else
static void
-header_iterate (rspamd_mempool_t * pool, GMimeHeaderList * ls, GList ** ret, const gchar *field, gboolean strong)
+header_iterate (rspamd_mempool_t * pool,
+ GMimeHeaderList * ls,
+ GList ** ret,
+ const gchar *field,
+ gboolean strong)
{
/* Use iterator in case of gmime 2.4 */
- GMimeHeaderIter *iter;
- const gchar *name;
+ GMimeHeaderIter *iter;
+ const gchar *name;
if (ls == NULL) {
*ret = NULL;
}
iter = g_mime_header_iter_new ();
- if (g_mime_header_list_get_iter (ls, iter) && g_mime_header_iter_first (iter)) {
+ if (g_mime_header_list_get_iter (ls,
+ iter) && g_mime_header_iter_first (iter)) {
/* Iterate throught headers */
while (g_mime_header_iter_is_valid (iter)) {
name = g_mime_header_iter_get_name (iter);
if (G_LIKELY (!strong)) {
if (!g_ascii_strncasecmp (field, name, strlen (name))) {
if (pool != NULL) {
- *ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, g_mime_header_iter_get_value (iter)));
+ *ret =
+ g_list_prepend (*ret,
+ rspamd_mempool_strdup (pool,
+ g_mime_header_iter_get_value (iter)));
}
else {
- *ret = g_list_prepend (*ret, g_strdup (g_mime_header_iter_get_value (iter)));
+ *ret =
+ g_list_prepend (*ret,
+ g_strdup (g_mime_header_iter_get_value (iter)));
}
}
}
else {
if (!strncmp (field, name, strlen (name))) {
if (pool != NULL) {
- *ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, g_mime_header_iter_get_value (iter)));
+ *ret =
+ g_list_prepend (*ret,
+ rspamd_mempool_strdup (pool,
+ g_mime_header_iter_get_value (iter)));
}
else {
- *ret = g_list_prepend (*ret, g_strdup (g_mime_header_iter_get_value (iter)));
+ *ret =
+ g_list_prepend (*ret,
+ g_strdup (g_mime_header_iter_get_value (iter)));
}
}
}
struct multipart_cb_data {
- GList *ret;
- rspamd_mempool_t *pool;
- const gchar *field;
- gboolean try_search;
- gboolean strong;
- gint rec;
+ GList *ret;
+ rspamd_mempool_t *pool;
+ const gchar *field;
+ gboolean try_search;
+ gboolean strong;
+ gint rec;
};
#define MAX_REC 10
multipart_iterate (GMimeObject * part, gpointer user_data)
#endif
{
- struct multipart_cb_data *data = user_data;
+ struct multipart_cb_data *data = user_data;
#ifndef GMIME24
- struct gmime_raw_header *h;
+ struct gmime_raw_header *h;
#endif
- GList *l = NULL;
+ GList *l = NULL;
if (data->try_search && part != NULL && GMIME_IS_PART (part)) {
#ifdef GMIME24
- GMimeHeaderList *ls;
+ GMimeHeaderList *ls;
ls = g_mime_object_get_header_list (GMIME_OBJECT (part));
header_iterate (data->pool, ls, &l, data->field, data->strong);
#else
h = (struct gmime_raw_header *)part->headers->headers;
- header_iterate (data->pool, h, &l, data->field, data->strong);
+ header_iterate (data->pool, h, &l, data->field, data->strong);
#endif
if (l == NULL) {
/* Header not found, abandon search results */
else if (data->try_search && GMIME_IS_MULTIPART (part)) {
/* Maybe endless recursion here ? */
if (data->rec++ < MAX_REC) {
- g_mime_multipart_foreach (GMIME_MULTIPART (part), multipart_iterate, data);
+ g_mime_multipart_foreach (GMIME_MULTIPART (
+ part), multipart_iterate, data);
}
else {
- msg_info ("maximum recurse limit is over, stop recursing, %d", data->rec);
+ msg_info ("maximum recurse limit is over, stop recursing, %d",
+ data->rec);
data->try_search = FALSE;
}
}
}
-static GList *
-local_message_get_header (rspamd_mempool_t * pool, GMimeMessage * message, const gchar *field, gboolean strong)
+static GList *
+local_message_get_header (rspamd_mempool_t * pool,
+ GMimeMessage * message,
+ const gchar *field,
+ gboolean strong)
{
- GList *gret = NULL;
- GMimeObject *part;
- struct multipart_cb_data cb = {
+ GList *gret = NULL;
+ GMimeObject *part;
+ struct multipart_cb_data cb = {
.try_search = TRUE,
.rec = 0,
.ret = NULL,
cb.strong = strong;
#ifndef GMIME24
- struct gmime_raw_header *h;
+ struct gmime_raw_header *h;
if (field == NULL) {
return NULL;
if (gret == NULL) {
/* Try to iterate with mime part headers */
- msg_debug ("iterate over headers of mime part to find header %s", field);
+ msg_debug ("iterate over headers of mime part to find header %s",
+ field);
part = g_mime_message_get_mime_part (message);
if (part) {
h = (struct gmime_raw_header *)part->headers->headers;
header_iterate (pool, h, &gret, field, strong);
if (gret == NULL && GMIME_IS_MULTIPART (part)) {
- msg_debug ("iterate over headers of each multipart's subparts %s", field);
- g_mime_multipart_foreach (GMIME_MULTIPART (part), multipart_iterate, &cb);
+ msg_debug (
+ "iterate over headers of each multipart's subparts %s",
+ field);
+ g_mime_multipart_foreach (GMIME_MULTIPART (
+ part), multipart_iterate, &cb);
if (cb.ret != NULL) {
gret = cb.ret;
}
return gret;
#else
- GMimeHeaderList *ls;
+ GMimeHeaderList *ls;
ls = g_mime_object_get_header_list (GMIME_OBJECT (message));
header_iterate (pool, ls, &gret, field, strong);
ls = g_mime_object_get_header_list (GMIME_OBJECT (part));
header_iterate (pool, ls, &gret, field, strong);
if (gret == NULL && GMIME_IS_MULTIPART (part)) {
- g_mime_multipart_foreach (GMIME_MULTIPART (part), multipart_iterate, &cb);
+ g_mime_multipart_foreach (GMIME_MULTIPART (
+ part), multipart_iterate, &cb);
if (cb.ret != NULL) {
gret = cb.ret;
}
}
/**
-* g_mime_message_set_date_from_string: Set the message sent-date
-* @message: MIME Message
-* @string: A string of date
-*
-* Set the sent-date on a MIME Message.
-**/
+ * g_mime_message_set_date_from_string: Set the message sent-date
+ * @message: MIME Message
+ * @string: A string of date
+ *
+ * Set the sent-date on a MIME Message.
+ **/
void
-local_mime_message_set_date_from_string (GMimeMessage * message, const gchar * string)
+local_mime_message_set_date_from_string (GMimeMessage * message,
+ const gchar * string)
{
- time_t date;
- gint offset = 0;
+ time_t date;
+ gint offset = 0;
date = g_mime_utils_header_decode_date (string, &offset);
g_mime_message_set_date (message, date, offset);
/*
* Replacements for standart gmime functions but converting adresses to IA
*/
-static const gchar *
+static const gchar *
local_message_get_sender (GMimeMessage * message)
{
- gchar *res;
- const gchar *from = g_mime_message_get_sender (message);
- InternetAddressList *ia;
+ gchar *res;
+ const gchar *from = g_mime_message_get_sender (message);
+ InternetAddressList *ia;
-#ifndef GMIME24
+#ifndef GMIME24
ia = internet_address_parse_string (from);
#else
ia = internet_address_list_parse_string (from);
return NULL;
}
res = internet_address_list_to_string (ia, FALSE);
-#ifndef GMIME24
+#ifndef GMIME24
internet_address_list_destroy (ia);
#else
g_object_unref (ia);
return res;
}
-static const gchar *
+static const gchar *
local_message_get_reply_to (GMimeMessage * message)
{
- gchar *res;
- const gchar *from = g_mime_message_get_reply_to (message);
- InternetAddressList *ia;
+ gchar *res;
+ const gchar *from = g_mime_message_get_reply_to (message);
+ InternetAddressList *ia;
-#ifndef GMIME24
+#ifndef GMIME24
ia = internet_address_parse_string (from);
#else
ia = internet_address_list_parse_string (from);
return NULL;
}
res = internet_address_list_to_string (ia, FALSE);
-#ifndef GMIME24
+#ifndef GMIME24
internet_address_list_destroy (ia);
#else
g_object_unref (ia);
#ifdef GMIME24
-# define ADD_RECIPIENT_TEMPLATE(type,def) \
-static void \
-local_message_add_recipients_from_string_##type (GMimeMessage *message, const gchar *string, const gchar *value) \
-{ \
- InternetAddressList *il, *new; \
- \
- il = g_mime_message_get_recipients (message, (def)); \
- new = internet_address_list_parse_string (string); \
- internet_address_list_append (il, new); \
-} \
-
-ADD_RECIPIENT_TEMPLATE (to, GMIME_RECIPIENT_TYPE_TO)
- ADD_RECIPIENT_TEMPLATE (cc, GMIME_RECIPIENT_TYPE_CC)
- ADD_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
-# define GET_RECIPIENT_TEMPLATE(type,def) \
-static InternetAddressList* \
-local_message_get_recipients_##type (GMimeMessage *message, const gchar *unused) \
-{ \
- return g_mime_message_get_recipients (message, (def)); \
-}
- GET_RECIPIENT_TEMPLATE (to, GMIME_RECIPIENT_TYPE_TO)
- GET_RECIPIENT_TEMPLATE (cc, GMIME_RECIPIENT_TYPE_CC)
- GET_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
+# define ADD_RECIPIENT_TEMPLATE(type,def) \
+ static void \
+ local_message_add_recipients_from_string_ ## type (GMimeMessage * message, \
+ const gchar * string, \
+ const gchar * value) \
+ { \
+ InternetAddressList *il, *new; \
+ \
+ il = g_mime_message_get_recipients (message, (def)); \
+ new = internet_address_list_parse_string (string); \
+ internet_address_list_append (il, new); \
+ } \
+
+ADD_RECIPIENT_TEMPLATE (to, GMIME_RECIPIENT_TYPE_TO)
+ADD_RECIPIENT_TEMPLATE (cc, GMIME_RECIPIENT_TYPE_CC)
+ADD_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
+# define GET_RECIPIENT_TEMPLATE(type,def) \
+ static InternetAddressList * \
+ local_message_get_recipients_ ## type (GMimeMessage * message, \
+ const gchar * unused) \
+ { \
+ return g_mime_message_get_recipients (message, (def)); \
+ }
+GET_RECIPIENT_TEMPLATE (to, GMIME_RECIPIENT_TYPE_TO)
+GET_RECIPIENT_TEMPLATE (cc, GMIME_RECIPIENT_TYPE_CC)
+GET_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
#endif
/* different declarations for different types of set and get functions */
- typedef const gchar *(*GetFunc) (GMimeMessage * message);
- typedef InternetAddressList *(*GetRcptFunc) (GMimeMessage * message, const gchar *type);
- typedef GList *(*GetListFunc) (rspamd_mempool_t * pool, GMimeMessage * message, const gchar *type, gboolean strong);
- typedef void (*SetFunc) (GMimeMessage * message, const gchar *value);
- typedef void (*SetListFunc) (GMimeMessage * message, const gchar *field, const gchar *value);
+typedef const gchar *(*GetFunc) (GMimeMessage * message);
+typedef InternetAddressList *(*GetRcptFunc) (GMimeMessage * message,
+ const gchar *type);
+typedef GList *(*GetListFunc) (rspamd_mempool_t * pool, GMimeMessage * message,
+ const gchar *type, gboolean strong);
+typedef void (*SetFunc) (GMimeMessage * message, const gchar *value);
+typedef void (*SetListFunc) (GMimeMessage * message, const gchar *field,
+ const gchar *value);
/** different types of functions
-*
-* FUNC_CHARPTR
-* - function with no arguments
-* - get returns gchar*
-*
-* FUNC_IA (from Internet Address)
-* - function with additional "field" argument from the fieldfunc table,
-* - get returns Glist*
-*
-* FUNC_LIST
-* - function with additional "field" argument (given arbitrary header field name)
-* - get returns Glist*
-**/
- enum {
- FUNC_CHARPTR = 0,
- FUNC_CHARFREEPTR,
- FUNC_IA,
- FUNC_LIST
- };
+ *
+ * FUNC_CHARPTR
+ * - function with no arguments
+ * - get returns gchar*
+ *
+ * FUNC_IA (from Internet Address)
+ * - function with additional "field" argument from the fieldfunc table,
+ * - get returns Glist*
+ *
+ * FUNC_LIST
+ * - function with additional "field" argument (given arbitrary header field name)
+ * - get returns Glist*
+ **/
+enum {
+ FUNC_CHARPTR = 0,
+ FUNC_CHARFREEPTR,
+ FUNC_IA,
+ FUNC_LIST
+};
/**
-* fieldfunc struct: structure of MIME fields and corresponding get and set
-* functions.
-**/
- static struct {
- gchar *name;
- GetFunc func;
- GetRcptFunc rcptfunc;
- GetListFunc getlistfunc;
- SetFunc setfunc;
- SetListFunc setlfunc;
- gint functype;
- } fieldfunc[] =
+ * fieldfunc struct: structure of MIME fields and corresponding get and set
+ * functions.
+ **/
+static struct {
+ gchar *name;
+ GetFunc func;
+ GetRcptFunc rcptfunc;
+ GetListFunc getlistfunc;
+ SetFunc setfunc;
+ SetListFunc setlfunc;
+ gint functype;
+} fieldfunc[] =
{
{
- "From", local_message_get_sender, NULL, NULL, g_mime_message_set_sender, NULL, FUNC_CHARFREEPTR}, {
- "Reply-To", local_message_get_reply_to, NULL, NULL, g_mime_message_set_reply_to, NULL, FUNC_CHARFREEPTR},
+ "From", local_message_get_sender, NULL, NULL, g_mime_message_set_sender,
+ NULL, FUNC_CHARFREEPTR
+ }, {
+ "Reply-To", local_message_get_reply_to, NULL, NULL,
+ g_mime_message_set_reply_to, NULL, FUNC_CHARFREEPTR
+ },
#ifndef GMIME24
{
- "To", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL, (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA}, {
- "Cc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL, (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA}, {
- "Bcc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL, (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA}, {
- "Date", (GetFunc) g_mime_message_get_date_string, NULL, NULL, local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR},
+ "To", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL,
+ (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA
+ }, {
+ "Cc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL,
+ (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA
+ }, {
+ "Bcc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL,
+ (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA
+ }, {
+ "Date", (GetFunc) g_mime_message_get_date_string, NULL, NULL,
+ local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR
+ },
#else
{
- "To", NULL, local_message_get_recipients_to, NULL, NULL, local_message_add_recipients_from_string_to, FUNC_IA}, {
- "Cc", NULL, local_message_get_recipients_cc, NULL, NULL, local_message_add_recipients_from_string_cc, FUNC_IA}, {
- "Bcc", NULL, local_message_get_recipients_bcc, NULL, NULL, local_message_add_recipients_from_string_bcc, FUNC_IA}, {
- "Date", (GetFunc)g_mime_message_get_date_as_string, NULL, NULL, local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR},
+ "To", NULL, local_message_get_recipients_to, NULL, NULL,
+ local_message_add_recipients_from_string_to, FUNC_IA
+ }, {
+ "Cc", NULL, local_message_get_recipients_cc, NULL, NULL,
+ local_message_add_recipients_from_string_cc, FUNC_IA
+ }, {
+ "Bcc", NULL, local_message_get_recipients_bcc, NULL, NULL,
+ local_message_add_recipients_from_string_bcc, FUNC_IA
+ }, {
+ "Date", (GetFunc)g_mime_message_get_date_as_string, NULL, NULL,
+ local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR
+ },
#endif
{
- "Subject", g_mime_message_get_subject, NULL, NULL, g_mime_message_set_subject, NULL, FUNC_CHARPTR}, {
- "Message-Id", g_mime_message_get_message_id, NULL, NULL, g_mime_message_set_message_id, NULL, FUNC_CHARPTR},
+ "Subject", g_mime_message_get_subject, NULL, NULL,
+ g_mime_message_set_subject, NULL, FUNC_CHARPTR
+ }, {
+ "Message-Id", g_mime_message_get_message_id, NULL, NULL,
+ g_mime_message_set_message_id, NULL, FUNC_CHARPTR
+ },
#ifndef GMIME24
{
- NULL, NULL, NULL, local_message_get_header, NULL, g_mime_message_add_header, FUNC_LIST}
+ NULL, NULL, NULL, local_message_get_header, NULL,
+ g_mime_message_add_header, FUNC_LIST
+ }
#else
{
- NULL, NULL, NULL, local_message_get_header, NULL, (SetListFunc)g_mime_object_append_header, FUNC_LIST}
+ NULL, NULL, NULL, local_message_get_header, NULL,
+ (SetListFunc)g_mime_object_append_header, FUNC_LIST
+ }
#endif
};
/**
-* message_set_header: set header of any type excluding special (Content- and MIME-Version:)
-**/
+ * message_set_header: set header of any type excluding special (Content- and MIME-Version:)
+ **/
void
-message_set_header (GMimeMessage * message, const gchar *field, const gchar *value)
+message_set_header (GMimeMessage * message,
+ const gchar *field,
+ const gchar *value)
{
- gint i;
+ gint i;
- if (!g_ascii_strcasecmp (field, "MIME-Version:") || !g_ascii_strncasecmp (field, "Content-", 8)) {
+ if (!g_ascii_strcasecmp (field,
+ "MIME-Version:") || !g_ascii_strncasecmp (field, "Content-", 8)) {
return;
}
for (i = 0; i <= HEADER_UNKNOWN; ++i) {
- if (!fieldfunc[i].name || !g_ascii_strncasecmp (field, fieldfunc[i].name, strlen (fieldfunc[i].name))) {
+ if (!fieldfunc[i].name ||
+ !g_ascii_strncasecmp (field, fieldfunc[i].name,
+ strlen (fieldfunc[i].name))) {
switch (fieldfunc[i].functype) {
case FUNC_CHARPTR:
- (*(fieldfunc[i].setfunc)) (message, value);
+ (*(fieldfunc[i].setfunc))(message, value);
break;
case FUNC_IA:
- (*(fieldfunc[i].setlfunc)) (message, fieldfunc[i].name, value);
+ (*(fieldfunc[i].setlfunc))(message, fieldfunc[i].name, value);
break;
case FUNC_LIST:
- (*(fieldfunc[i].setlfunc)) (message, field, value);
+ (*(fieldfunc[i].setlfunc))(message, field, value);
break;
}
break;
/**
-* message_get_header: returns the list of 'any header' values
-* (except of unsupported yet Content- and MIME-Version special headers)
-*
-* You should free the GList list by yourself.
-**/
-GList *
-message_get_header (rspamd_mempool_t * pool, GMimeMessage * message, const gchar *field, gboolean strong)
+ * message_get_header: returns the list of 'any header' values
+ * (except of unsupported yet Content- and MIME-Version special headers)
+ *
+ * You should free the GList list by yourself.
+ **/
+GList *
+message_get_header (rspamd_mempool_t * pool,
+ GMimeMessage * message,
+ const gchar *field,
+ gboolean strong)
{
- gint i;
- gchar *ret = NULL, *ia_string;
- GList *gret = NULL;
- InternetAddressList *ia_list = NULL, *ia;
+ gint i;
+ gchar *ret = NULL, *ia_string;
+ GList *gret = NULL;
+ InternetAddressList *ia_list = NULL, *ia;
for (i = 0; i <= HEADER_UNKNOWN; ++i) {
- if (!fieldfunc[i].name || !g_ascii_strncasecmp (field, fieldfunc[i].name, strlen (fieldfunc[i].name))) {
+ if (!fieldfunc[i].name ||
+ !g_ascii_strncasecmp (field, fieldfunc[i].name,
+ strlen (fieldfunc[i].name))) {
switch (fieldfunc[i].functype) {
case FUNC_CHARFREEPTR:
- ret = (gchar *)(*(fieldfunc[i].func)) (message);
+ ret = (gchar *)(*(fieldfunc[i].func))(message);
break;
case FUNC_CHARPTR:
- ret = (gchar *)(*(fieldfunc[i].func)) (message);
+ ret = (gchar *)(*(fieldfunc[i].func))(message);
break;
case FUNC_IA:
- ia_list = (*(fieldfunc[i].rcptfunc)) (message, field);
+ ia_list = (*(fieldfunc[i].rcptfunc))(message, field);
ia = ia_list;
#ifndef GMIME24
while (ia && ia->address) {
- ia_string = internet_address_to_string ((InternetAddress *) ia->address, FALSE);
+ ia_string = internet_address_to_string (
+ (InternetAddress *) ia->address,
+ FALSE);
if (pool != NULL) {
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_free, ia_string);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_free, ia_string);
}
gret = g_list_prepend (gret, ia_string);
ia = ia->next;
#else
i = internet_address_list_length (ia);
while (--i >= 0) {
- ia_string = internet_address_to_string (internet_address_list_get_address (ia, i), FALSE);
+ ia_string = internet_address_to_string (internet_address_list_get_address (
+ ia,
+ i),
+ FALSE);
if (pool != NULL) {
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_free, ia_string);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_free, ia_string);
}
gret = g_list_prepend (gret, ia_string);
}
#endif
break;
case FUNC_LIST:
- gret = (*(fieldfunc[i].getlistfunc)) (pool, message, field, strong);
+ gret =
+ (*(fieldfunc[i].getlistfunc))(pool, message, field, strong);
break;
}
break;
return gret;
}
-GList*
-message_get_raw_header (struct rspamd_task *task, const gchar *field, gboolean strong)
+GList *
+message_get_raw_header (struct rspamd_task *task,
+ const gchar *field,
+ gboolean strong)
{
- GList *gret = NULL;
- struct raw_header *rh;
+ GList *gret = NULL;
+ struct raw_header *rh;
rh = g_hash_table_lookup (task->raw_headers, field);
}
if (gret != NULL) {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, gret);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, gret);
}
return gret;
GByteArray *orig;
GByteArray *content;
GNode *html_nodes;
- GList *urls_offset; /**< list of offsets of urls */
+ GList *urls_offset; /**< list of offsets of urls */
fuzzy_hash_t *fuzzy;
fuzzy_hash_t *double_fuzzy;
GMimeObject *parent;
};
/**
- * Process message with all filters/statfiles, extract mime parts, urls and
+ * Process message with all filters/statfiles, extract mime parts, urls and
* call metrics consolidation functions
* @param task worker_task object
* @return 0 if we have delayed filters to process and 1 if we have finished with processing
/*
* Set header with specified name and value
*/
-void message_set_header (GMimeMessage *message, const gchar *field, const gchar *value);
+void message_set_header (GMimeMessage *message,
+ const gchar *field,
+ const gchar *value);
/*
* Get a list of header's values with specified header's name
* @param strong if this flag is TRUE header's name is case sensitive, otherwise it is not
* @return A list of header's values or NULL. If list is not NULL it MUST be freed. If pool is NULL elements must be freed as well.
*/
-GList* message_get_header (rspamd_mempool_t *pool, GMimeMessage *message, const gchar *field, gboolean strong);
+GList * message_get_header (rspamd_mempool_t *pool,
+ GMimeMessage *message,
+ const gchar *field,
+ gboolean strong);
/*
* Get a list of header's values with specified header's name using raw headers
* @param strong if this flag is TRUE header's name is case sensitive, otherwise it is not
* @return A list of header's values or NULL. Unlike previous function it is NOT required to free list or values. I should rework one of these functions some time.
*/
-GList* message_get_raw_header (struct rspamd_task *task, const gchar *field, gboolean strong);
+GList * message_get_raw_header (struct rspamd_task *task,
+ const gchar *field,
+ gboolean strong);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "cfg_file.h"
#include "config.h"
#include "main.h"
-#include "cfg_file.h"
-#include "util.h"
#include "smtp.h"
#include "smtp_proto.h"
#include "smtp_utils.h"
+#include "util.h"
-gchar *
-make_smtp_error (rspamd_mempool_t *pool, gint error_code, const gchar *format, ...)
+gchar *
+make_smtp_error (rspamd_mempool_t *pool,
+ gint error_code,
+ const gchar *format,
+ ...)
{
- va_list vp;
- gchar *result = NULL, *p;
- size_t len;
-
+ va_list vp;
+ gchar *result = NULL, *p;
+ size_t len;
+
va_start (vp, format);
len = g_printf_string_upper_bound (format, vp);
va_end (vp);
gboolean
-parse_smtp_command (struct smtp_session *session, f_str_t *line, struct smtp_command **cmd)
+parse_smtp_command (struct smtp_session *session,
+ f_str_t *line,
+ struct smtp_command **cmd)
{
enum {
SMTP_PARSE_START = 0,
SMTP_PARSE_ARGUMENT,
SMTP_PARSE_DONE
} state;
- gchar *p, *c, ch, cmd_buf[4];
- guint i;
- f_str_t *arg = NULL;
- struct smtp_command *pcmd;
-
+ gchar *p, *c, ch, cmd_buf[4];
+ guint i;
+ f_str_t *arg = NULL;
+ struct smtp_command *pcmd;
+
if (line->len == 0) {
return FALSE;
}
*cmd = rspamd_mempool_alloc0 (session->pool, sizeof (struct smtp_command));
pcmd = *cmd;
- for (i = 0; i < line->len; i ++, p ++) {
+ for (i = 0; i < line->len; i++, p++) {
ch = *p;
switch (state) {
- case SMTP_PARSE_START:
- if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i == line->len - 1) {
- if (i == line->len - 1) {
- p ++;
+ case SMTP_PARSE_START:
+ if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i ==
+ line->len - 1) {
+ if (i == line->len - 1) {
+ p++;
+ }
+ if (p - c == 4) {
+ cmd_buf[0] = g_ascii_toupper (c[0]);
+ cmd_buf[1] = g_ascii_toupper (c[1]);
+ cmd_buf[2] = g_ascii_toupper (c[2]);
+ cmd_buf[3] = g_ascii_toupper (c[3]);
+
+ if (memcmp (cmd_buf, "HELO", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_HELO;
}
- if (p - c == 4) {
- cmd_buf[0] = g_ascii_toupper (c[0]);
- cmd_buf[1] = g_ascii_toupper (c[1]);
- cmd_buf[2] = g_ascii_toupper (c[2]);
- cmd_buf[3] = g_ascii_toupper (c[3]);
-
- if (memcmp (cmd_buf, "HELO", 4) == 0) {
- pcmd->command = SMTP_COMMAND_HELO;
- }
- else if (memcmp (cmd_buf, "EHLO", 4) == 0) {
- pcmd->command = SMTP_COMMAND_EHLO;
- }
- else if (memcmp (cmd_buf, "MAIL", 4) == 0) {
- pcmd->command = SMTP_COMMAND_MAIL;
- }
- else if (memcmp (cmd_buf, "RCPT", 4) == 0) {
- pcmd->command = SMTP_COMMAND_RCPT;
- }
- else if (memcmp (cmd_buf, "DATA", 4) == 0) {
- pcmd->command = SMTP_COMMAND_DATA;
- }
- else if (memcmp (cmd_buf, "QUIT", 4) == 0) {
- pcmd->command = SMTP_COMMAND_QUIT;
- }
- else if (memcmp (cmd_buf, "NOOP", 4) == 0) {
- pcmd->command = SMTP_COMMAND_NOOP;
- }
- else if (memcmp (cmd_buf, "EXPN", 4) == 0) {
- pcmd->command = SMTP_COMMAND_EXPN;
- }
- else if (memcmp (cmd_buf, "RSET", 4) == 0) {
- pcmd->command = SMTP_COMMAND_RSET;
- }
- else if (memcmp (cmd_buf, "HELP", 4) == 0) {
- pcmd->command = SMTP_COMMAND_HELP;
- }
- else if (memcmp (cmd_buf, "VRFY", 4) == 0) {
- pcmd->command = SMTP_COMMAND_VRFY;
- }
- else {
- msg_info ("invalid command: %*s", 4, cmd_buf);
- return FALSE;
- }
+ else if (memcmp (cmd_buf, "EHLO", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_EHLO;
}
- else {
- /* Invalid command */
- msg_info ("invalid command: %*s", 4, c);
- return FALSE;
+ else if (memcmp (cmd_buf, "MAIL", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_MAIL;
}
- /* Now check what we have */
- if (ch == ' ' || ch == ':') {
- state = SMTP_PARSE_SPACES;
+ else if (memcmp (cmd_buf, "RCPT", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_RCPT;
}
- else if (ch == CR) {
- state = SMTP_PARSE_DONE;
+ else if (memcmp (cmd_buf, "DATA", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_DATA;
}
- else if (ch == LF) {
- return TRUE;
+ else if (memcmp (cmd_buf, "QUIT", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_QUIT;
+ }
+ else if (memcmp (cmd_buf, "NOOP", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_NOOP;
+ }
+ else if (memcmp (cmd_buf, "EXPN", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_EXPN;
+ }
+ else if (memcmp (cmd_buf, "RSET", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_RSET;
+ }
+ else if (memcmp (cmd_buf, "HELP", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_HELP;
+ }
+ else if (memcmp (cmd_buf, "VRFY", 4) == 0) {
+ pcmd->command = SMTP_COMMAND_VRFY;
+ }
+ else {
+ msg_info ("invalid command: %*s", 4, cmd_buf);
+ return FALSE;
}
}
- else if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
- msg_info ("invalid letter code in SMTP command: %d", (gint)ch);
+ else {
+ /* Invalid command */
+ msg_info ("invalid command: %*s", 4, c);
return FALSE;
}
- break;
- case SMTP_PARSE_SPACES:
- if (ch == CR) {
+ /* Now check what we have */
+ if (ch == ' ' || ch == ':') {
+ state = SMTP_PARSE_SPACES;
+ }
+ else if (ch == CR) {
state = SMTP_PARSE_DONE;
}
else if (ch == LF) {
- goto end;
+ return TRUE;
}
- else if (ch != ' ' && ch != ':') {
- state = SMTP_PARSE_ARGUMENT;
- arg = rspamd_mempool_alloc (session->pool, sizeof (f_str_t));
- c = p;
- }
- break;
- case SMTP_PARSE_ARGUMENT:
- if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i == line->len - 1) {
- if (i == line->len - 1 && (ch != ' ' && ch != CR && ch != LF)) {
- p ++;
- }
- arg->len = p - c;
- arg->begin = rspamd_mempool_alloc (session->pool, arg->len);
- memcpy (arg->begin, c, arg->len);
- pcmd->args = g_list_prepend (pcmd->args, arg);
- if (ch == ' ' || ch == ':') {
- state = SMTP_PARSE_SPACES;
- }
- else if (ch == CR) {
- state = SMTP_PARSE_DONE;
- }
- else {
- goto end;
- }
+ }
+ else if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
+ msg_info ("invalid letter code in SMTP command: %d", (gint)ch);
+ return FALSE;
+ }
+ break;
+ case SMTP_PARSE_SPACES:
+ if (ch == CR) {
+ state = SMTP_PARSE_DONE;
+ }
+ else if (ch == LF) {
+ goto end;
+ }
+ else if (ch != ' ' && ch != ':') {
+ state = SMTP_PARSE_ARGUMENT;
+ arg = rspamd_mempool_alloc (session->pool, sizeof (f_str_t));
+ c = p;
+ }
+ break;
+ case SMTP_PARSE_ARGUMENT:
+ if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i ==
+ line->len - 1) {
+ if (i == line->len - 1 && (ch != ' ' && ch != CR && ch != LF)) {
+ p++;
+ }
+ arg->len = p - c;
+ arg->begin = rspamd_mempool_alloc (session->pool, arg->len);
+ memcpy (arg->begin, c, arg->len);
+ pcmd->args = g_list_prepend (pcmd->args, arg);
+ if (ch == ' ' || ch == ':') {
+ state = SMTP_PARSE_SPACES;
+ }
+ else if (ch == CR) {
+ state = SMTP_PARSE_DONE;
}
- break;
- case SMTP_PARSE_DONE:
- if (ch == LF) {
+ else {
goto end;
}
- msg_info ("CR without LF in SMTP command");
- return FALSE;
+ }
+ break;
+ case SMTP_PARSE_DONE:
+ if (ch == LF) {
+ goto end;
+ }
+ msg_info ("CR without LF in SMTP command");
+ return FALSE;
}
}
end:
if (pcmd->args) {
pcmd->args = g_list_reverse (pcmd->args);
- rspamd_mempool_add_destructor (session->pool, (rspamd_mempool_destruct_t)g_list_free, pcmd->args);
+ rspamd_mempool_add_destructor (session->pool,
+ (rspamd_mempool_destruct_t)g_list_free,
+ pcmd->args);
}
return TRUE;
}
static gboolean
check_smtp_path (f_str_t *path)
{
- guint i;
- gchar *p;
+ guint i;
+ gchar *p;
p = path->begin;
if (*p != '<' || path->len < 2) {
return FALSE;
}
- for (i = 0; i < path->len; i++, p ++) {
+ for (i = 0; i < path->len; i++, p++) {
if (*p == '>' && i != path->len - 1) {
return FALSE;
}
gboolean
parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd)
{
- f_str_t *arg;
+ f_str_t *arg;
if (cmd->args == NULL) {
session->error = SMTP_ERROR_BAD_ARGUMENTS;
gboolean
parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd)
{
- f_str_t *arg;
- GList *cur = cmd->args;
+ f_str_t *arg;
+ GList *cur = cmd->args;
if (cmd->args == NULL) {
session->error = SMTP_ERROR_BAD_ARGUMENTS;
arg = cur->data;
/* First argument MUST be FROM */
if (arg->len != 4 || (
- g_ascii_toupper (arg->begin[0]) != 'F' ||
- g_ascii_toupper (arg->begin[1]) != 'R' ||
- g_ascii_toupper (arg->begin[2]) != 'O' ||
- g_ascii_toupper (arg->begin[3]) != 'M')) {
+ g_ascii_toupper (arg->begin[0]) != 'F' ||
+ g_ascii_toupper (arg->begin[1]) != 'R' ||
+ g_ascii_toupper (arg->begin[2]) != 'O' ||
+ g_ascii_toupper (arg->begin[3]) != 'M')) {
session->error = SMTP_ERROR_BAD_ARGUMENTS;
return FALSE;
}
gboolean
parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd)
{
- f_str_t *arg;
- GList *cur = cmd->args;
+ f_str_t *arg;
+ GList *cur = cmd->args;
if (cmd->args == NULL) {
session->error = SMTP_ERROR_BAD_ARGUMENTS;
arg = cur->data;
/* First argument MUST be FROM */
if (arg->len != 2 || (
- g_ascii_toupper (arg->begin[0]) != 'T' ||
- g_ascii_toupper (arg->begin[1]) != 'O')) {
+ g_ascii_toupper (arg->begin[0]) != 'T' ||
+ g_ascii_toupper (arg->begin[1]) != 'O')) {
session->error = SMTP_ERROR_BAD_ARGUMENTS;
return FALSE;
}
static gint
check_smtp_ustream_reply (f_str_t *in, gchar success_code)
{
- gchar *p;
+ gchar *p;
/* Check for 250 at the begin of line */
if (in->len >= sizeof ("220 ") - 1) {
size_t
smtp_upstream_write_list (GList *args, gchar *buf, size_t buflen)
{
- GList *cur = args;
- size_t r = 0;
- f_str_t *arg;
+ GList *cur = args;
+ size_t r = 0;
+ f_str_t *arg;
while (cur && r < buflen - 3) {
arg = cur->data;
- r += rspamd_snprintf (buf + r, buflen - r, " %V", arg);
+ r += rspamd_snprintf (buf + r, buflen - r, " %V", arg);
cur = g_list_next (cur);
}
return r;
}
-gboolean
+gboolean
smtp_upstream_write_socket (void *arg)
{
- struct smtp_session *session = arg;
-
+ struct smtp_session *session = arg;
+
if (session->upstream_state == SMTP_STATE_IN_SENDFILE) {
session->upstream_state = SMTP_STATE_AFTER_DATA;
- return rspamd_dispatcher_write (session->upstream_dispatcher, CRLF DATA_END_TRAILER, sizeof (CRLF DATA_END_TRAILER) - 1, FALSE, TRUE);
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ CRLF DATA_END_TRAILER,
+ sizeof (CRLF DATA_END_TRAILER) - 1,
+ FALSE,
+ TRUE);
}
return TRUE;
}
-gboolean
+gboolean
smtp_upstream_read_socket (f_str_t * in, void *arg)
{
- struct smtp_session *session = arg;
- gchar outbuf[BUFSIZ];
- gint r;
-
+ struct smtp_session *session = arg;
+ gchar outbuf[BUFSIZ];
+ gint r;
+
msg_debug ("in: %V, state: %d", in, session->upstream_state);
switch (session->upstream_state) {
- case SMTP_STATE_GREETING:
- r = check_smtp_ustream_reply (in, '2');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* XXX: assume upstream errors as critical errors */
- session->state = SMTP_STATE_CRITICAL_ERROR;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- destroy_session (session->s);
- return FALSE;
+ case SMTP_STATE_GREETING:
+ r = check_smtp_ustream_reply (in, '2');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ /* XXX: assume upstream errors as critical errors */
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ in->len, FALSE, TRUE)) {
+ goto err;
}
- else if (r == 1) {
- if (session->ctx->use_xclient) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "XCLIENT NAME=%s ADDR=%s" CRLF,
- session->resolved ? session->hostname : "[UNDEFINED]",
- inet_ntoa (session->client_addr));
- session->upstream_state = SMTP_STATE_HELO;
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
- }
- else {
- session->upstream_state = SMTP_STATE_FROM;
- if (session->helo) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF,
- session->esmtp ? "EHLO" : "HELO",
- session->helo);
- }
- else {
- return smtp_upstream_read_socket (in, arg);
- }
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
- }
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
+ goto err;
}
- break;
- case SMTP_STATE_HELO:
- r = check_smtp_ustream_reply (in, '2');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* XXX: assume upstream errors as critical errors */
- session->state = SMTP_STATE_CRITICAL_ERROR;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- destroy_session (session->s);
- return FALSE;
+ destroy_session (session->s);
+ return FALSE;
+ }
+ else if (r == 1) {
+ if (session->ctx->use_xclient) {
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "XCLIENT NAME=%s ADDR=%s" CRLF,
+ session->resolved ? session->hostname : "[UNDEFINED]",
+ inet_ntoa (session->client_addr));
+ session->upstream_state = SMTP_STATE_HELO;
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
}
- else if (r == 1) {
+ else {
session->upstream_state = SMTP_STATE_FROM;
if (session->helo) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF,
- session->esmtp ? "EHLO" : "HELO",
- session->helo);
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF,
+ session->esmtp ? "EHLO" : "HELO",
+ session->helo);
}
else {
return smtp_upstream_read_socket (in, arg);
}
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
}
- break;
- case SMTP_STATE_FROM:
- r = check_smtp_ustream_reply (in, '2');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* XXX: assume upstream errors as critical errors */
- session->state = SMTP_STATE_CRITICAL_ERROR;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- destroy_session (session->s);
- return FALSE;
+ }
+ break;
+ case SMTP_STATE_HELO:
+ r = check_smtp_ustream_reply (in, '2');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ /* XXX: assume upstream errors as critical errors */
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ in->len, FALSE, TRUE)) {
+ goto err;
}
- else if (r == 1) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: ");
- r += smtp_upstream_write_list (session->from, outbuf + r, sizeof (outbuf) - r);
- session->upstream_state = SMTP_STATE_RCPT;
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
+ goto err;
}
- break;
- case SMTP_STATE_RCPT:
- r = check_smtp_ustream_reply (in, '2');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* XXX: assume upstream errors as critical errors */
- session->state = SMTP_STATE_CRITICAL_ERROR;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- destroy_session (session->s);
- return FALSE;
+ destroy_session (session->s);
+ return FALSE;
+ }
+ else if (r == 1) {
+ session->upstream_state = SMTP_STATE_FROM;
+ if (session->helo) {
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF,
+ session->esmtp ? "EHLO" : "HELO",
+ session->helo);
}
- else if (r == 1) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
- session->cur_rcpt = g_list_first (session->rcpt);
- r += smtp_upstream_write_list (session->cur_rcpt->data, outbuf + r, sizeof (outbuf) - r);
- session->cur_rcpt = g_list_next (session->cur_rcpt);
- session->upstream_state = SMTP_STATE_BEFORE_DATA;
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+ else {
+ return smtp_upstream_read_socket (in, arg);
}
- break;
- case SMTP_STATE_BEFORE_DATA:
- r = check_smtp_ustream_reply (in, '2');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- if (session->cur_rcpt) {
- session->rcpt = g_list_delete_link (session->rcpt, session->cur_rcpt);
- }
- else {
- session->rcpt = g_list_delete_link (session->rcpt, session->rcpt);
- }
- session->errors ++;
- session->state = SMTP_STATE_RCPT;
- return TRUE;
- }
- else if (r == 1) {
- if (session->cur_rcpt != NULL) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
- r += smtp_upstream_write_list (session->cur_rcpt, outbuf + r, sizeof (outbuf) - r);
- session->cur_rcpt = g_list_next (session->cur_rcpt);
- if (! rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE)) {
- goto err;
- }
- }
- else {
- session->upstream_state = SMTP_STATE_DATA;
- rspamd_dispatcher_pause (session->upstream_dispatcher);
- }
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* Write to client */
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- if (session->state == SMTP_STATE_WAIT_UPSTREAM) {
- rspamd_dispatcher_restore (session->dispatcher);
- session->state = SMTP_STATE_RCPT;
- }
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
+ }
+ break;
+ case SMTP_STATE_FROM:
+ r = check_smtp_ustream_reply (in, '2');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ /* XXX: assume upstream errors as critical errors */
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ in->len, FALSE, TRUE)) {
+ goto err;
}
- break;
- case SMTP_STATE_DATA:
- r = check_smtp_ustream_reply (in, '3');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* XXX: assume upstream errors as critical errors */
- session->state = SMTP_STATE_CRITICAL_ERROR;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
- goto err;
- }
- destroy_session (session->s);
- return FALSE;
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
+ goto err;
}
- else if (r == 1) {
- if (! make_smtp_tempfile (session)) {
- session->error = SMTP_ERROR_FILE;
- session->state = SMTP_STATE_CRITICAL_ERROR;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
- goto err;
- }
- destroy_session (session->s);
- return FALSE;
- }
- session->state = SMTP_STATE_AFTER_DATA;
- session->error = SMTP_ERROR_DATA_OK;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ destroy_session (session->s);
+ return FALSE;
+ }
+ else if (r == 1) {
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: ");
+ r +=
+ smtp_upstream_write_list (session->from,
+ outbuf + r,
+ sizeof (outbuf) - r);
+ session->upstream_state = SMTP_STATE_RCPT;
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
+ }
+ break;
+ case SMTP_STATE_RCPT:
+ r = check_smtp_ustream_reply (in, '2');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ /* XXX: assume upstream errors as critical errors */
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ in->len, FALSE, TRUE)) {
+ goto err;
+ }
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
+ goto err;
+ }
+ destroy_session (session->s);
+ return FALSE;
+ }
+ else if (r == 1) {
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
+ session->cur_rcpt = g_list_first (session->rcpt);
+ r += smtp_upstream_write_list (session->cur_rcpt->data,
+ outbuf + r,
+ sizeof (outbuf) - r);
+ session->cur_rcpt = g_list_next (session->cur_rcpt);
+ session->upstream_state = SMTP_STATE_BEFORE_DATA;
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
+ }
+ break;
+ case SMTP_STATE_BEFORE_DATA:
+ r = check_smtp_ustream_reply (in, '2');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ in->len, FALSE, TRUE)) {
+ goto err;
+ }
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
+ goto err;
+ }
+ if (session->cur_rcpt) {
+ session->rcpt = g_list_delete_link (session->rcpt,
+ session->cur_rcpt);
+ }
+ else {
+ session->rcpt =
+ g_list_delete_link (session->rcpt, session->rcpt);
+ }
+ session->errors++;
+ session->state = SMTP_STATE_RCPT;
+ return TRUE;
+ }
+ else if (r == 1) {
+ if (session->cur_rcpt != NULL) {
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
+ r += smtp_upstream_write_list (session->cur_rcpt,
+ outbuf + r,
+ sizeof (outbuf) - r);
+ session->cur_rcpt = g_list_next (session->cur_rcpt);
+ if (!rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf, r, FALSE, FALSE)) {
goto err;
}
+ }
+ else {
+ session->upstream_state = SMTP_STATE_DATA;
rspamd_dispatcher_pause (session->upstream_dispatcher);
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0);
- session->dispatcher->strip_eol = FALSE;
- return TRUE;
}
- break;
- case SMTP_STATE_AFTER_DATA:
session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
rspamd_strlcpy (session->error, in->begin, in->len + 1);
- session->state = SMTP_STATE_DATA;
- rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ /* Write to client */
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ in->len, FALSE, TRUE)) {
goto err;
}
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
goto err;
}
- if (! rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF, sizeof ("QUIT" CRLF) - 1, FALSE, TRUE)) {
+ if (session->state == SMTP_STATE_WAIT_UPSTREAM) {
+ rspamd_dispatcher_restore (session->dispatcher);
+ session->state = SMTP_STATE_RCPT;
+ }
+ }
+ break;
+ case SMTP_STATE_DATA:
+ r = check_smtp_ustream_reply (in, '3');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ /* XXX: assume upstream errors as critical errors */
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
goto err;
}
- session->upstream_state = SMTP_STATE_END;
- return TRUE;
- break;
- case SMTP_STATE_END:
- r = check_smtp_ustream_reply (in, '5');
- if (r == -1) {
- session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
- rspamd_strlcpy (session->error, in->begin, in->len + 1);
- /* XXX: assume upstream errors as critical errors */
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
+ goto err;
+ }
+ destroy_session (session->s);
+ return FALSE;
+ }
+ else if (r == 1) {
+ if (!make_smtp_tempfile (session)) {
+ session->error = SMTP_ERROR_FILE;
session->state = SMTP_STATE_CRITICAL_ERROR;
rspamd_dispatcher_restore (session->dispatcher);
- if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
- goto err;
- }
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ session->error, 0, FALSE, TRUE)) {
goto err;
}
destroy_session (session->s);
return FALSE;
}
- else {
- remove_normal_event (session->s, (event_finalizer_t)smtp_upstream_finalize_connection, session);
+ session->state = SMTP_STATE_AFTER_DATA;
+ session->error = SMTP_ERROR_DATA_OK;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
+ goto err;
}
- return FALSE;
- break;
- default:
- msg_err ("got upstream reply at unexpected state: %d, reply: %V", session->upstream_state, in);
+ rspamd_dispatcher_pause (session->upstream_dispatcher);
+ rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0);
+ session->dispatcher->strip_eol = FALSE;
+ return TRUE;
+ }
+ break;
+ case SMTP_STATE_AFTER_DATA:
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ session->state = SMTP_STATE_DATA;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0,
+ FALSE, TRUE)) {
+ goto err;
+ }
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) -
+ 1, FALSE, TRUE)) {
+ goto err;
+ }
+ if (!rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF,
+ sizeof ("QUIT" CRLF) - 1, FALSE, TRUE)) {
+ goto err;
+ }
+ session->upstream_state = SMTP_STATE_END;
+ return TRUE;
+ break;
+ case SMTP_STATE_END:
+ r = check_smtp_ustream_reply (in, '5');
+ if (r == -1) {
+ session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+ rspamd_strlcpy (session->error, in->begin, in->len + 1);
+ /* XXX: assume upstream errors as critical errors */
session->state = SMTP_STATE_CRITICAL_ERROR;
rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
goto err;
}
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
+ sizeof (CRLF) - 1, FALSE, TRUE)) {
goto err;
}
destroy_session (session->s);
return FALSE;
+ }
+ else {
+ remove_normal_event (session->s,
+ (event_finalizer_t)smtp_upstream_finalize_connection,
+ session);
+ }
+ return FALSE;
+ break;
+ default:
+ msg_err ("got upstream reply at unexpected state: %d, reply: %V",
+ session->upstream_state,
+ in);
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ rspamd_dispatcher_restore (session->dispatcher);
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0,
+ FALSE, TRUE)) {
+ goto err;
+ }
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) -
+ 1, FALSE, TRUE)) {
+ goto err;
+ }
+ destroy_session (session->s);
+ return FALSE;
}
return TRUE;
return FALSE;
}
-void
+void
smtp_upstream_err_socket (GError *err, void *arg)
{
- struct smtp_session *session = arg;
+ struct smtp_session *session = arg;
- msg_info ("abnormally closing connection with upstream %s, error: %s", session->upstream->name, err->message);
+ msg_info ("abnormally closing connection with upstream %s, error: %s",
+ session->upstream->name,
+ err->message);
session->error = SMTP_ERROR_UPSTREAM;
session->state = SMTP_STATE_CRITICAL_ERROR;
/* XXX: assume upstream errors as critical errors */
rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
+ TRUE)) {
return;
}
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1,
+ FALSE, TRUE)) {
return;
}
upstream_fail (&session->upstream->up, session->session_time);
void
smtp_upstream_finalize_connection (gpointer data)
{
- struct smtp_session *session = data;
-
+ struct smtp_session *session = data;
+
if (session->state != SMTP_STATE_CRITICAL_ERROR) {
- if (! rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF,
+ 0, FALSE, TRUE)) {
msg_warn ("cannot send correctly closing message to upstream");
}
}
/* SMTP errors */
#define SMTP_ERROR_BAD_COMMAND "500 Syntax error, command unrecognized" CRLF
-#define SMTP_ERROR_BAD_ARGUMENTS "501 Syntax error in parameters or arguments" CRLF
+#define SMTP_ERROR_BAD_ARGUMENTS "501 Syntax error in parameters or arguments" \
+ CRLF
#define SMTP_ERROR_SEQUENCE "503 Bad sequence of commands" CRLF
#define SMTP_ERROR_RECIPIENTS "554 No valid recipients" CRLF
#define SMTP_ERROR_UNIMPLIMENTED "502 Command not implemented" CRLF
#define SMTP_ERROR_LIMIT "505 Too many errors. Aborting." CRLF
-#define SMTP_ERROR_UPSTREAM "421 Service not available, closing transmission channel" CRLF
+#define SMTP_ERROR_UPSTREAM \
+ "421 Service not available, closing transmission channel" CRLF
#define SMTP_ERROR_FILE "420 Service not available, filesystem error" CRLF
#define SMTP_ERROR_OK "250 Requested mail action okay, completed" CRLF
#define SMTP_ERROR_DATA_OK "354 Start mail input; end with <CRLF>.<CRLF>" CRLF
/*
* Generate SMTP error message
*/
-gchar * make_smtp_error (rspamd_mempool_t *pool, gint error_code, const gchar *format, ...);
+gchar * make_smtp_error (rspamd_mempool_t *pool,
+ gint error_code,
+ const gchar *format,
+ ...);
/*
* Parse a single SMTP command
*/
-gboolean parse_smtp_command (struct smtp_session *session, f_str_t *line, struct smtp_command **cmd);
+gboolean parse_smtp_command (struct smtp_session *session,
+ f_str_t *line,
+ struct smtp_command **cmd);
/*
* Parse HELO command
*/
-gboolean parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd);
+gboolean parse_smtp_helo (struct smtp_session *session,
+ struct smtp_command *cmd);
/*
* Parse MAIL command
*/
-gboolean parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd);
+gboolean parse_smtp_from (struct smtp_session *session,
+ struct smtp_command *cmd);
/*
* Parse RCPT command
*/
-gboolean parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd);
+gboolean parse_smtp_rcpt (struct smtp_session *session,
+ struct smtp_command *cmd);
/* Upstream SMTP */
*/
#include "config.h"
-#include "main.h"
#include "filter.h"
+#include "main.h"
#include "smtp.h"
#include "smtp_proto.h"
void
free_smtp_session (gpointer arg)
{
- struct smtp_session *session = arg;
+ struct smtp_session *session = arg;
if (session) {
if (session->task) {
gboolean
create_smtp_upstream_connection (struct smtp_session *session)
{
- struct smtp_upstream *selected;
+ struct smtp_upstream *selected;
/* Try to select upstream */
- selected = (struct smtp_upstream *)get_upstream_round_robin (session->ctx->upstreams,
- session->ctx->upstream_num, sizeof (struct smtp_upstream),
- session->session_time, DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
+ selected = (struct smtp_upstream *)get_upstream_round_robin (
+ session->ctx->upstreams,
+ session->ctx->upstream_num,
+ sizeof (struct smtp_upstream),
+ session->session_time,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS);
if (selected == NULL) {
msg_err ("no upstreams suitable found");
return FALSE;
session->upstream = selected;
/* Now try to create socket */
- session->upstream_sock = make_universal_socket (selected->addr, selected->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+ session->upstream_sock = make_universal_socket (selected->addr,
+ selected->port,
+ SOCK_STREAM,
+ TRUE,
+ FALSE,
+ FALSE);
if (session->upstream_sock == -1) {
msg_err ("cannot make a connection to %s", selected->name);
upstream_fail (&selected->up, session->session_time);
return FALSE;
}
/* Create a dispatcher for upstream connection */
- session->upstream_dispatcher = rspamd_create_dispatcher (session->ev_base, session->upstream_sock, BUFFER_LINE,
- smtp_upstream_read_socket, smtp_upstream_write_socket, smtp_upstream_err_socket,
- &session->ctx->smtp_timeout, session);
+ session->upstream_dispatcher = rspamd_create_dispatcher (session->ev_base,
+ session->upstream_sock,
+ BUFFER_LINE,
+ smtp_upstream_read_socket,
+ smtp_upstream_write_socket,
+ smtp_upstream_err_socket,
+ &session->ctx->smtp_timeout,
+ session);
session->state = SMTP_STATE_WAIT_UPSTREAM;
session->upstream_state = SMTP_STATE_GREETING;
- register_async_event (session->s, (event_finalizer_t)smtp_upstream_finalize_connection, session, g_quark_from_static_string ("smtp proxy"));
+ register_async_event (session->s,
+ (event_finalizer_t)smtp_upstream_finalize_connection,
+ session,
+ g_quark_from_static_string ("smtp proxy"));
return TRUE;
}
session->upstream_state = SMTP_STATE_IN_SENDFILE;
session->state = SMTP_STATE_WAIT_UPSTREAM;
- if (! rspamd_dispatcher_sendfile (session->upstream_dispatcher, session->temp_fd, session->temp_size)) {
+ if (!rspamd_dispatcher_sendfile (session->upstream_dispatcher,
+ session->temp_fd, session->temp_size)) {
msg_err ("sendfile failed: %s", strerror (errno));
goto err;
}
err:
session->error = SMTP_ERROR_FILE;
session->state = SMTP_STATE_CRITICAL_ERROR;
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
+ TRUE)) {
return FALSE;
}
destroy_session (session->s);
}
struct smtp_metric_callback_data {
- struct smtp_session *session;
- enum rspamd_metric_action action;
- struct metric_result *res;
- gchar *log_buf;
- gint log_offset;
- gint log_size;
- gboolean alive;
+ struct smtp_session *session;
+ enum rspamd_metric_action action;
+ struct metric_result *res;
+ gchar *log_buf;
+ gint log_offset;
+ gint log_size;
+ gboolean alive;
};
static void
smtp_metric_symbols_callback (gpointer key, gpointer value, void *user_data)
{
- struct smtp_metric_callback_data *cd = user_data;
+ struct smtp_metric_callback_data *cd = user_data;
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "%s,", (gchar *)key);
+ cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
+ cd->log_size - cd->log_offset,
+ "%s,",
+ (gchar *)key);
}
static void
smtp_metric_callback (gpointer key, gpointer value, gpointer ud)
{
struct smtp_metric_callback_data *cd = ud;
- struct metric_result *metric_res = value;
- enum rspamd_metric_action action = METRIC_ACTION_NOACTION;
- double ms = 0, rs = 0;
- gboolean is_spam = FALSE;
- struct rspamd_task *task;
+ struct metric_result *metric_res = value;
+ enum rspamd_metric_action action = METRIC_ACTION_NOACTION;
+ double ms = 0, rs = 0;
+ gboolean is_spam = FALSE;
+ struct rspamd_task *task;
task = cd->session->task;
ms = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
rs = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
}
- if (! check_metric_action_settings (task, metric_res, metric_res->score, &action)) {
- action = check_metric_action (metric_res->score, ms, metric_res->metric);
+ if (!check_metric_action_settings (task, metric_res, metric_res->score,
+ &action)) {
+ action =
+ check_metric_action (metric_res->score, ms, metric_res->metric);
}
#endif
if (metric_res->score >= ms) {
}
if (!task->is_skipped) {
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "(%s: %c (%s): [%.2f/%.2f/%.2f] [",
- (gchar *)key, is_spam ? 'T' : 'F', str_action_metric (action), metric_res->score, ms, rs);
+ cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
+ cd->log_size - cd->log_offset,
+ "(%s: %c (%s): [%.2f/%.2f/%.2f] [",
+ (gchar *)key,
+ is_spam ? 'T' : 'F',
+ str_action_metric (action),
+ metric_res->score,
+ ms,
+ rs);
}
else {
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "(%s: %c (default): [%.2f/%.2f/%.2f] [",
- (gchar *)key, 'S', metric_res->score, ms, rs);
+ cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
+ cd->log_size - cd->log_offset,
+ "(%s: %c (default): [%.2f/%.2f/%.2f] [",
+ (gchar *)key,
+ 'S',
+ metric_res->score,
+ ms,
+ rs);
}
- g_hash_table_foreach (metric_res->symbols, smtp_metric_symbols_callback, cd);
+ g_hash_table_foreach (metric_res->symbols, smtp_metric_symbols_callback,
+ cd);
/* Remove last , from log buf */
if (cd->log_buf[cd->log_offset - 1] == ',') {
cd->log_buf[--cd->log_offset] = '\0';
}
#ifdef HAVE_CLOCK_GETTIME
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "]), len: %z, time: %s,",
- task->msg->len, calculate_check_time (&task->tv, &task->ts, task->cfg->clock_res, &task->scan_milliseconds));
+ cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
+ cd->log_size - cd->log_offset,
+ "]), len: %z, time: %s,",
+ task->msg->len,
+ calculate_check_time (&task->tv, &task->ts, task->cfg->clock_res,
+ &task->scan_milliseconds));
#else
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "]), len: %z, time: %s,",
- task->msg->len, calculate_check_time (&task->tv, task->cfg->clock_res, &task->scan_milliseconds));
+ cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
+ cd->log_size - cd->log_offset,
+ "]), len: %z, time: %s,",
+ task->msg->len,
+ calculate_check_time (&task->tv, task->cfg->clock_res,
+ &task->scan_milliseconds));
#endif
}
gboolean
make_smtp_tempfile (struct smtp_session *session)
{
- gsize r;
+ gsize r;
r = strlen (session->cfg->temp_dir) + sizeof ("/rspamd-XXXXXX");
session->temp_name = rspamd_mempool_alloc (session->pool, r);
- rspamd_snprintf (session->temp_name, r, "%s%crspamd-XXXXXX", session->cfg->temp_dir, G_DIR_SEPARATOR);
+ rspamd_snprintf (session->temp_name,
+ r,
+ "%s%crspamd-XXXXXX",
+ session->cfg->temp_dir,
+ G_DIR_SEPARATOR);
#ifdef HAVE_MKSTEMP
/* Umask is set before */
session->temp_fd = mkstemp (session->temp_name);
#else
- session->temp_fd = g_mkstemp_full (session->temp_name, O_RDWR, S_IWUSR | S_IRUSR);
+ session->temp_fd = g_mkstemp_full (session->temp_name,
+ O_RDWR,
+ S_IWUSR | S_IRUSR);
#endif
if (session->temp_fd == -1) {
msg_err ("mkstemp error: %s", strerror (errno));
gboolean
write_smtp_reply (struct smtp_session *session)
{
- gchar logbuf[1024], *new_subject;
- const gchar *old_subject;
+ gchar logbuf[1024], *new_subject;
+ const gchar *old_subject;
struct smtp_metric_callback_data cd;
- GMimeStream *stream;
- gint old_fd, sublen;
+ GMimeStream *stream;
+ gint old_fd, sublen;
/* Check metrics */
cd.session = session;
cd.action = METRIC_ACTION_NOACTION;
cd.res = NULL;
cd.log_buf = logbuf;
- cd.log_offset = rspamd_snprintf (logbuf, sizeof (logbuf), "id: <%s>, qid: <%s>, ",
- session->task->message_id, session->task->queue_id);
+ cd.log_offset = rspamd_snprintf (logbuf,
+ sizeof (logbuf),
+ "id: <%s>, qid: <%s>, ",
+ session->task->message_id,
+ session->task->queue_id);
cd.log_size = sizeof (logbuf);
if (session->task->user) {
- cd.log_offset += rspamd_snprintf (logbuf + cd.log_offset, sizeof (logbuf) - cd.log_offset,
- "user: %s, ", session->task->user);
+ cd.log_offset += rspamd_snprintf (logbuf + cd.log_offset,
+ sizeof (logbuf) - cd.log_offset,
+ "user: %s, ",
+ session->task->user);
}
g_hash_table_foreach (session->task->results, smtp_metric_callback, &cd);
msg_info ("%s", logbuf);
if (cd.action <= METRIC_ACTION_REJECT) {
- if (! rspamd_dispatcher_write (session->dispatcher, session->ctx->reject_message, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ session->ctx->reject_message, 0, FALSE, TRUE)) {
return FALSE;
}
- if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) -
+ 1, FALSE, TRUE)) {
return FALSE;
}
destroy_session (session->s);
return FALSE;
}
- else if (cd.action <= METRIC_ACTION_ADD_HEADER || cd.action <= METRIC_ACTION_REWRITE_SUBJECT) {
+ else if (cd.action <= METRIC_ACTION_ADD_HEADER || cd.action <=
+ METRIC_ACTION_REWRITE_SUBJECT) {
old_fd = session->temp_fd;
- if (! make_smtp_tempfile (session)) {
+ if (!make_smtp_tempfile (session)) {
session->error = SMTP_ERROR_FILE;
session->state = SMTP_STATE_CRITICAL_ERROR;
rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
goto err;
}
destroy_session (session->s);
if (old_subject != NULL) {
sublen = strlen (old_subject) + sizeof (SPAM_SUBJECT);
new_subject = rspamd_mempool_alloc (session->pool, sublen);
- rspamd_snprintf (new_subject, sublen, "%s%s", SPAM_SUBJECT, old_subject);
+ rspamd_snprintf (new_subject,
+ sublen,
+ "%s%s",
+ SPAM_SUBJECT,
+ old_subject);
}
else {
new_subject = SPAM_SUBJECT;
}
else if (cd.action <= METRIC_ACTION_ADD_HEADER) {
#ifndef GMIME24
- g_mime_message_add_header (session->task->message, "X-Spam", "true");
+ g_mime_message_add_header (session->task->message, "X-Spam",
+ "true");
#else
- g_mime_object_append_header (GMIME_OBJECT (session->task->message), "X-Spam", "true");
+ g_mime_object_append_header (GMIME_OBJECT (
+ session->task->message), "X-Spam", "true");
#endif
}
stream = g_mime_stream_fs_new (session->temp_fd);
g_mime_stream_fs_set_owner (GMIME_STREAM_FS (stream), FALSE);
close (old_fd);
- if (g_mime_object_write_to_stream (GMIME_OBJECT (session->task->message), stream) == -1) {
- msg_err ("cannot write MIME object to stream: %s", strerror (errno));
+ if (g_mime_object_write_to_stream (GMIME_OBJECT (session->task->message),
+ stream) == -1) {
+ msg_err ("cannot write MIME object to stream: %s",
+ strerror (errno));
session->error = SMTP_ERROR_FILE;
session->state = SMTP_STATE_CRITICAL_ERROR;
rspamd_dispatcher_restore (session->dispatcher);
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
goto err;
}
destroy_session (session->s);
err:
session->error = SMTP_ERROR_FILE;
session->state = SMTP_STATE_CRITICAL_ERROR;
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
+ TRUE)) {
return FALSE;
}
destroy_session (session->s);
}
gboolean
-parse_upstreams_line (rspamd_mempool_t *pool, struct smtp_upstream *upstreams, const gchar *line, gsize *count)
+parse_upstreams_line (rspamd_mempool_t *pool,
+ struct smtp_upstream *upstreams,
+ const gchar *line,
+ gsize *count)
{
- gchar **strv, *p, *t, *tt, *err_str;
- guint32 num, i;
- struct smtp_upstream *cur;
- gchar resolved_path[PATH_MAX];
+ gchar **strv, *p, *t, *tt, *err_str;
+ guint32 num, i;
+ struct smtp_upstream *cur;
+ gchar resolved_path[PATH_MAX];
strv = g_strsplit_set (line, ",; ", -1);
num = g_strv_length (strv);
if (num >= MAX_SMTP_UPSTREAMS) {
- msg_err ("cannot define %d upstreams %d is max", num, MAX_SMTP_UPSTREAMS);
+ msg_err ("cannot define %d upstreams %d is max", num,
+ MAX_SMTP_UPSTREAMS);
return FALSE;
}
*count = 0;
- for (i = 0; i < num; i ++) {
+ for (i = 0; i < num; i++) {
p = strv[i];
cur = &upstreams[*count];
if ((t = strrchr (p, ':')) != NULL && (tt = strchr (p, ':')) != t) {
/* Assume that after last `:' we have weigth */
*t = '\0';
- t ++;
+ t++;
errno = 0;
cur->up.priority = strtoul (t, &err_str, 10);
if (errno != 0 || (err_str && *err_str != '\0')) {
return FALSE;
}
cur->name = rspamd_mempool_strdup (pool, resolved_path);
- (*count) ++;
+ (*count)++;
}
else {
- if (! rspamd_parse_host_port (pool, p, &cur->addr, &cur->port)) {
+ if (!rspamd_parse_host_port (pool, p, &cur->addr, &cur->port)) {
g_strfreev (strv);
return FALSE;
}
cur->name = rspamd_mempool_strdup (pool, p);
- (*count) ++;
+ (*count)++;
}
}
* @param count targeted count
* @return
*/
-gboolean parse_upstreams_line (rspamd_mempool_t *pool, struct smtp_upstream *upstreams, const gchar *line, gsize *count);
+gboolean parse_upstreams_line (rspamd_mempool_t *pool,
+ struct smtp_upstream *upstreams,
+ const gchar *line,
+ gsize *count);
#endif /* SMTP_UTILS_H_ */
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
#include "binlog.h"
#include "cfg_file.h"
+#include "config.h"
#include "tokenizers/tokenizers.h"
#define BINLOG_SUFFIX ".binlog"
static GHashTable *binlog_opened = NULL;
static rspamd_mempool_t *binlog_pool = NULL;
-static gboolean
+static gboolean
binlog_write_header (struct rspamd_binlog *log)
{
struct rspamd_binlog_header header = {
.version = VALID_VERSION,
.padding = { '\0', '\0' },
};
-
+
header.create_time = time (NULL);
lock_file (log->fd, FALSE);
-
+
if (write (log->fd, &header, sizeof (struct rspamd_binlog_header)) == -1) {
- msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot write file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
memcpy (&log->header, &header, sizeof (struct rspamd_binlog_header));
-
+
/* Metaindex */
log->metaindex = g_malloc (sizeof (struct rspamd_binlog_metaindex));
bzero (log->metaindex, sizeof (struct rspamd_binlog_metaindex));
/* Offset to metaindex */
- log->metaindex->indexes[0] = sizeof (struct rspamd_binlog_metaindex) + sizeof (struct rspamd_binlog_header);
+ log->metaindex->indexes[0] = sizeof (struct rspamd_binlog_metaindex) +
+ sizeof (struct rspamd_binlog_header);
- if (write (log->fd, log->metaindex, sizeof (struct rspamd_binlog_metaindex)) == -1) {
+ if (write (log->fd, log->metaindex,
+ sizeof (struct rspamd_binlog_metaindex)) == -1) {
g_free (log->metaindex);
- msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot write file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
unlock_file (log->fd, FALSE);
return FALSE;
}
/* Alloc, write, mmap */
log->cur_idx = g_malloc (sizeof (struct rspamd_index_block));
bzero (log->cur_idx, sizeof (struct rspamd_index_block));
- if (write (log->fd, log->cur_idx, sizeof (struct rspamd_index_block)) == -1) {
+ if (write (log->fd, log->cur_idx,
+ sizeof (struct rspamd_index_block)) == -1) {
g_free (log->cur_idx);
- msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot write file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
unlock_file (log->fd, FALSE);
return FALSE;
}
{
static gchar valid_magic[] = VALID_MAGIC, valid_version[] = VALID_VERSION;
- if (read (log->fd, &log->header, sizeof (struct rspamd_binlog_header)) != sizeof (struct rspamd_binlog_header)) {
- msg_warn ("cannot read file %s, error %d, %s", log->filename, errno, strerror (errno));
+ if (read (log->fd, &log->header,
+ sizeof (struct rspamd_binlog_header)) !=
+ sizeof (struct rspamd_binlog_header)) {
+ msg_warn ("cannot read file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
/* Now check all fields */
- if (memcmp (&log->header.magic, valid_magic, sizeof (valid_magic)) != 0 ||
- memcmp (&log->header.version, valid_version, sizeof (valid_version)) != 0) {
+ if (memcmp (&log->header.magic, valid_magic, sizeof (valid_magic)) != 0 ||
+ memcmp (&log->header.version, valid_version,
+ sizeof (valid_version)) != 0) {
msg_warn ("cannot validate file %s");
return FALSE;
}
if (log->metaindex == NULL) {
log->metaindex = g_malloc (sizeof (struct rspamd_binlog_metaindex));
}
- if ((read (log->fd, log->metaindex, sizeof (struct rspamd_binlog_metaindex))) != sizeof (struct rspamd_binlog_metaindex)) {
- msg_warn ("cannot read metaindex of file %s, error %d, %s", log->filename, errno, strerror (errno));
+ if ((read (log->fd, log->metaindex,
+ sizeof (struct rspamd_binlog_metaindex))) !=
+ sizeof (struct rspamd_binlog_metaindex)) {
+ msg_warn ("cannot read metaindex of file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
/* Current index */
if (log->cur_idx == NULL) {
log->cur_idx = g_malloc (sizeof (struct rspamd_index_block));
}
- if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index], SEEK_SET) == -1) {
- msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
+ if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index],
+ SEEK_SET) == -1) {
+ msg_info ("cannot seek in file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
- if ((read (log->fd, log->cur_idx, sizeof (struct rspamd_index_block))) != sizeof (struct rspamd_index_block)) {
- msg_warn ("cannot read index in file %s, error %d, %s", log->filename, errno, strerror (errno));
+ if ((read (log->fd, log->cur_idx,
+ sizeof (struct rspamd_index_block))) !=
+ sizeof (struct rspamd_index_block)) {
+ msg_warn ("cannot read index in file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
- log->cur_seq = log->metaindex->last_index * BINLOG_IDX_LEN + log->cur_idx->last_index;
+ log->cur_seq = log->metaindex->last_index * BINLOG_IDX_LEN +
+ log->cur_idx->last_index;
log->cur_time = log->cur_idx->indexes[log->cur_idx->last_index].time;
return TRUE;
static gboolean
binlog_create (struct rspamd_binlog *log)
{
- if ((log->fd = open (log->filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
- msg_info ("cannot create file %s, error %d, %s", log->filename, errno, strerror (errno));
+ if ((log->fd =
+ open (log->filename, O_RDWR | O_TRUNC | O_CREAT,
+ S_IWUSR | S_IRUSR)) == -1) {
+ msg_info ("cannot create file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
binlog_open_real (struct rspamd_binlog *log)
{
if ((log->fd = open (log->filename, O_RDWR)) == -1) {
- msg_info ("cannot open file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_info ("cannot open file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
-
+
return binlog_check_file (log);
}
-struct rspamd_binlog*
-binlog_open (rspamd_mempool_t *pool, const gchar *path, time_t rotate_time, gint rotate_jitter)
+struct rspamd_binlog *
+binlog_open (rspamd_mempool_t *pool,
+ const gchar *path,
+ time_t rotate_time,
+ gint rotate_jitter)
{
struct rspamd_binlog *new;
- gint len = strlen (path);
+ gint len = strlen (path);
struct stat st;
new = rspamd_mempool_alloc0 (pool, sizeof (struct rspamd_binlog));
if (rotate_time) {
new->rotate_jitter = g_random_int_range (0, rotate_jitter);
}
-
+
new->filename = rspamd_mempool_alloc (pool, len + sizeof (BINLOG_SUFFIX));
- rspamd_strlcpy (new->filename, path, len + 1);
+ rspamd_strlcpy (new->filename, path, len + 1);
rspamd_strlcpy (new->filename + len, BINLOG_SUFFIX, sizeof (BINLOG_SUFFIX));
if (stat (new->filename, &st) == -1) {
/* Check errno to check whether we should create this file */
if (errno != ENOENT) {
- msg_err ("cannot stat file: %s, error %s", new->filename, strerror (errno));
+ msg_err ("cannot stat file: %s, error %s", new->filename,
+ strerror (errno));
return NULL;
}
else {
return new;
}
-void
+void
binlog_close (struct rspamd_binlog *log)
{
if (log) {
static gboolean
binlog_tree_callback (gpointer key, gpointer value, gpointer data)
{
- token_node_t *node = key;
- struct rspamd_binlog *log = data;
- struct rspamd_binlog_element elt;
+ token_node_t *node = key;
+ struct rspamd_binlog *log = data;
+ struct rspamd_binlog_element elt;
elt.h1 = node->h1;
elt.h2 = node->h2;
elt.value = node->value;
-
+
if (write (log->fd, &elt, sizeof (elt)) == -1) {
- msg_info ("cannot write token to file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot write token to file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return TRUE;
}
struct rspamd_binlog_index *idx;
lock_file (log->fd, FALSE);
- log->cur_seq ++;
+ log->cur_seq++;
/* Seek to end of file */
if ((seek = lseek (log->fd, 0, SEEK_END)) == -1) {
unlock_file (log->fd, FALSE);
- msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot seek in file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
idx->time = (guint64)time (NULL);
log->cur_time = idx->time;
idx->len = g_tree_nnodes (nodes) * sizeof (struct rspamd_binlog_element);
- if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index], SEEK_SET) == -1) {
+ if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index],
+ SEEK_SET) == -1) {
unlock_file (log->fd, FALSE);
- msg_info ("cannot seek in file: %s, error: %s, seek: %L, op: insert index", log->filename,
- strerror (errno), log->metaindex->indexes[log->metaindex->last_index]);
+ msg_info (
+ "cannot seek in file: %s, error: %s, seek: %L, op: insert index",
+ log->filename,
+ strerror (errno),
+ log->metaindex->indexes[log->metaindex->last_index]);
return FALSE;
}
- log->cur_idx->last_index ++;
- if (write (log->fd, log->cur_idx, sizeof (struct rspamd_index_block)) == -1) {
+ log->cur_idx->last_index++;
+ if (write (log->fd, log->cur_idx,
+ sizeof (struct rspamd_index_block)) == -1) {
unlock_file (log->fd, FALSE);
- msg_info ("cannot write index to file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot write index to file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
unlock_file (log->fd, FALSE);
-
+
return TRUE;
}
off_t seek;
lock_file (log->fd, FALSE);
-
- log->metaindex->last_index ++;
+
+ log->metaindex->last_index++;
/* Seek to end of file */
if ((seek = lseek (log->fd, 0, SEEK_END)) == -1) {
unlock_file (log->fd, FALSE);
- msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot seek in file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
- if (write (log->fd, log->cur_idx, sizeof (struct rspamd_index_block)) == -1) {
+ if (write (log->fd, log->cur_idx,
+ sizeof (struct rspamd_index_block)) == -1) {
unlock_file (log->fd, FALSE);
g_free (log->cur_idx);
- msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot write file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
/* Offset to metaindex */
/* Overwrite all metaindexes */
if (lseek (log->fd, sizeof (struct rspamd_binlog_header), SEEK_SET) == -1) {
unlock_file (log->fd, FALSE);
- msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot seek in file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
- if (write (log->fd, log->metaindex, sizeof (struct rspamd_binlog_metaindex)) == -1) {
+ if (write (log->fd, log->metaindex,
+ sizeof (struct rspamd_binlog_metaindex)) == -1) {
unlock_file (log->fd, FALSE);
- msg_info ("cannot write metaindex in file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot write metaindex in file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
bzero (log->cur_idx, sizeof (struct rspamd_index_block));
static gboolean
maybe_rotate_binlog (struct rspamd_binlog *log)
{
- guint64 now = time (NULL);
+ guint64 now = time (NULL);
- if (log->rotate_time && ((now - log->header.create_time) > (guint)(log->rotate_time + log->rotate_jitter))) {
+ if (log->rotate_time &&
+ ((now - log->header.create_time) >
+ (guint)(log->rotate_time + log->rotate_jitter))) {
return TRUE;
}
return FALSE;
static gboolean
rotate_binlog (struct rspamd_binlog *log)
{
- gchar *backup_name;
+ gchar *backup_name;
struct stat st;
lock_file (log->fd, FALSE);
}
-gboolean
+gboolean
binlog_insert (struct rspamd_binlog *log, GTree *nodes)
{
off_t seek;
if (!log || !log->metaindex || !log->cur_idx || !nodes) {
- msg_info ("improperly opened binlog: %s", log != NULL ? log->filename : "unknown");
+ msg_info ("improperly opened binlog: %s",
+ log != NULL ? log->filename : "unknown");
return FALSE;
}
if (log->metaindex->last_index < METAINDEX_LEN) {
/* Create new index block */
if ((seek = lseek (log->fd, 0, SEEK_END)) == (off_t)-1) {
- msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
+ msg_info ("cannot seek in file: %s, error: %s",
+ log->filename,
+ strerror (errno));
return FALSE;
}
if (!create_new_metaindex_block (log)) {
}
return write_binlog_tree (log, nodes);
}
-
+
/* All binlog is filled, we need to rotate it forcefully */
if (!rotate_binlog (log)) {
return FALSE;
return write_binlog_tree (log, nodes);
}
-gboolean
-binlog_sync (struct rspamd_binlog *log, guint64 from_rev, guint64 *from_time, GByteArray **rep)
+gboolean
+binlog_sync (struct rspamd_binlog *log,
+ guint64 from_rev,
+ guint64 *from_time,
+ GByteArray **rep)
{
- guint32 metaindex_num;
+ guint32 metaindex_num;
struct rspamd_index_block *idxb;
struct rspamd_binlog_index *idx;
gboolean idx_mapped = FALSE, res = TRUE, is_first = FALSE;
if (!log || !log->metaindex || !log->cur_idx) {
- msg_info ("improperly opened binlog: %s", log != NULL ? log->filename : "unknown");
+ msg_info ("improperly opened binlog: %s",
+ log != NULL ? log->filename : "unknown");
return FALSE;
}
/* Unmap old fragment */
g_free ((*rep)->data);
}
-
+
if (from_rev == log->cur_seq) {
/* Last record */
*rep = NULL;
}
else if (from_rev > log->cur_seq) {
/* Slave has more actual copy, write this to log and abort sync */
- msg_warn ("slave has more recent revision of statfile %s: %uL and our is: %uL", log->filename, from_rev, log->cur_seq);
+ msg_warn (
+ "slave has more recent revision of statfile %s: %uL and our is: %uL",
+ log->filename,
+ from_rev,
+ log->cur_seq);
*rep = NULL;
*from_time = 0;
return FALSE;
lock_file (log->fd, FALSE);
idxb = g_malloc (sizeof (struct rspamd_index_block));
idx_mapped = TRUE;
- if (lseek (log->fd, log->metaindex->indexes[metaindex_num], SEEK_SET) == -1) {
+ if (lseek (log->fd, log->metaindex->indexes[metaindex_num],
+ SEEK_SET) == -1) {
unlock_file (log->fd, FALSE);
- msg_warn ("cannot seek file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot seek file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
res = FALSE;
goto end;
}
- if ((read (log->fd, idxb, sizeof (struct rspamd_index_block))) != sizeof (struct rspamd_index_block)) {
+ if ((read (log->fd, idxb,
+ sizeof (struct rspamd_index_block))) !=
+ sizeof (struct rspamd_index_block)) {
unlock_file (log->fd, FALSE);
- msg_warn ("cannot read index from file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot read index from file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
res = FALSE;
goto end;
}
/* Now fill reply structure */
(*rep)->len = idx->len;
/* Read result */
- msg_info ("update from binlog '%s' from revision: %uL to revision %uL size is %uL",
- log->filename, from_rev, log->cur_seq, idx->len);
+ msg_info (
+ "update from binlog '%s' from revision: %uL to revision %uL size is %uL",
+ log->filename,
+ from_rev,
+ log->cur_seq,
+ idx->len);
if (lseek (log->fd, idx->seek, SEEK_SET) == -1) {
- msg_warn ("cannot seek file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot seek file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
res = FALSE;
goto end;
}
-
+
(*rep)->data = g_malloc (idx->len);
if ((read (log->fd, (*rep)->data, idx->len)) != (ssize_t)idx->len) {
- msg_warn ("cannot read file %s, error %d, %s", log->filename, errno, strerror (errno));
+ msg_warn ("cannot read file %s, error %d, %s",
+ log->filename,
+ errno,
+ strerror (errno));
res = FALSE;
goto end;
}
return TRUE;
}
-gboolean
-maybe_write_binlog (struct rspamd_classifier_config *ccf, struct rspamd_statfile_config *st, stat_file_t *file, GTree *nodes)
+gboolean
+maybe_write_binlog (struct rspamd_classifier_config *ccf,
+ struct rspamd_statfile_config *st,
+ stat_file_t *file,
+ GTree *nodes)
{
struct rspamd_binlog *log;
return FALSE;
}
-
- if (st == NULL || nodes == NULL || st->binlog == NULL || st->binlog->affinity != AFFINITY_MASTER) {
+
+ if (st == NULL || nodes == NULL || st->binlog == NULL ||
+ st->binlog->affinity != AFFINITY_MASTER) {
return FALSE;
}
}
if ((log = g_hash_table_lookup (binlog_opened, st)) == NULL) {
- if ((log = binlog_open (binlog_pool, st->path, st->binlog->rotate_time, st->binlog->rotate_time / 2)) != NULL) {
+ if ((log =
+ binlog_open (binlog_pool, st->path, st->binlog->rotate_time,
+ st->binlog->rotate_time / 2)) != NULL) {
g_hash_table_insert (binlog_opened, st, log);
}
else {
}
if (binlog_insert (log, nodes)) {
- msg_info ("set new revision of statfile %s: %uL", st->symbol, log->cur_seq);
+ msg_info ("set new revision of statfile %s: %uL",
+ st->symbol,
+ log->cur_seq);
(void)statfile_set_revision (file, log->cur_seq, log->cur_time);
return TRUE;
}
return FALSE;
}
-struct rspamd_binlog*
+struct rspamd_binlog *
get_binlog_by_statfile (struct rspamd_statfile_config *st)
{
struct rspamd_binlog *log;
- if (st == NULL || st->binlog == NULL || st->binlog->affinity != AFFINITY_MASTER) {
+ if (st == NULL || st->binlog == NULL || st->binlog->affinity !=
+ AFFINITY_MASTER) {
return NULL;
}
}
if ((log = g_hash_table_lookup (binlog_opened, st)) == NULL) {
- if ((log = binlog_open (binlog_pool, st->path, st->binlog->rotate_time, st->binlog->rotate_time / 2)) != NULL) {
+ if ((log =
+ binlog_open (binlog_pool, st->path, st->binlog->rotate_time,
+ st->binlog->rotate_time / 2)) != NULL) {
g_hash_table_insert (binlog_opened, st, log);
}
else {
return NULL;
}
}
-
+
return log;
}
/*
* Open binlog at specified path with specified rotate params
*/
-struct rspamd_binlog* binlog_open (rspamd_mempool_t *pool, const gchar *path, time_t rotate_time, gint rotate_jitter);
+struct rspamd_binlog * binlog_open (rspamd_mempool_t *pool,
+ const gchar *path,
+ time_t rotate_time,
+ gint rotate_jitter);
/*
* Get and open binlog for specified statfile
*/
-struct rspamd_binlog* get_binlog_by_statfile (struct rspamd_statfile_config *st);
+struct rspamd_binlog * get_binlog_by_statfile (struct rspamd_statfile_config *st);
/*
* Close binlog
* @param rep a portion of changes for revision is stored here
* @return TRUE if there are more revisions to get and FALSE if synchronization is complete
*/
-gboolean binlog_sync (struct rspamd_binlog *log, guint64 from_rev, guint64 *from_time, GByteArray **rep);
+gboolean binlog_sync (struct rspamd_binlog *log,
+ guint64 from_rev,
+ guint64 *from_time,
+ GByteArray **rep);
/*
* Conditional write to a binlog for specified statfile
*/
-gboolean maybe_write_binlog (struct rspamd_classifier_config *ccf, struct rspamd_statfile_config *st, stat_file_t *file, GTree *nodes);
+gboolean maybe_write_binlog (struct rspamd_classifier_config *ccf,
+ struct rspamd_statfile_config *st,
+ stat_file_t *file,
+ GTree *nodes);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
#include "buffer.h"
+#include "config.h"
#include "main.h"
#ifdef HAVE_SYS_SENDFILE_H
#include <sys/sendfile.h>
#endif
-#define G_DISPATCHER_ERROR dispatcher_error_quark()
-#define debug_ip(...) rspamd_conditional_debug(rspamd_main->logger, NULL, __FUNCTION__, __VA_ARGS__)
+#define G_DISPATCHER_ERROR dispatcher_error_quark ()
+#define debug_ip(...) rspamd_conditional_debug (rspamd_main->logger, \
+ NULL, \
+ __FUNCTION__, \
+ __VA_ARGS__)
-static void dispatcher_cb (gint fd, short what, void *arg);
+static void dispatcher_cb (gint fd, short what, void *arg);
-static inline GQuark
+static inline GQuark
dispatcher_error_quark (void)
{
return g_quark_from_static_string ("g-dispatcher-error-quark");
sendfile_callback (rspamd_io_dispatcher_t *d)
{
- GError *err;
+ GError *err;
#ifdef HAVE_SENDFILE
# if defined(FREEBSD) || defined(DARWIN)
- off_t off = 0;
+ off_t off = 0;
#if defined(FREEBSD)
/* FreeBSD version */
if (sendfile (d->sendfile_fd, d->fd, d->offset, 0, NULL, &off, 0) != 0) {
#endif
if (errno != EAGAIN) {
if (d->err_callback) {
- err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
+ err =
+ g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
+ errno));
d->err_callback (err, d->user_data);
return FALSE;
}
}
else {
- debug_ip("partially write data, retry");
+ debug_ip ("partially write data, retry");
/* Wait for other event */
d->offset += off;
event_del (d->ev);
else {
if (d->write_callback) {
if (!d->write_callback (d->user_data)) {
- debug_ip("callback set wanna_die flag, terminating");
+ debug_ip ("callback set wanna_die flag, terminating");
return FALSE;
}
}
event_del (d->ev);
- event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
+ event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb,
+ (void *)d);
event_base_set (d->ev_base, d->ev);
event_add (d->ev, d->tv);
d->in_sendfile = FALSE;
}
# else
- ssize_t r;
+ ssize_t r;
/* Linux version */
r = sendfile (d->fd, d->sendfile_fd, &d->offset, d->file_size);
if (r == -1) {
if (errno != EAGAIN) {
if (d->err_callback) {
- err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
+ err =
+ g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
+ errno));
d->err_callback (err, d->user_data);
return FALSE;
}
}
else {
- debug_ip("partially write data, retry");
+ debug_ip ("partially write data, retry");
/* Wait for other event */
event_del (d->ev);
event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
}
}
else if (r + d->offset < (ssize_t)d->file_size) {
- debug_ip("partially write data, retry");
+ debug_ip ("partially write data, retry");
/* Wait for other event */
event_del (d->ev);
event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
else {
if (d->write_callback) {
if (!d->write_callback (d->user_data)) {
- debug_ip("callback set wanna_die flag, terminating");
+ debug_ip ("callback set wanna_die flag, terminating");
return FALSE;
}
}
event_del (d->ev);
- event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
+ event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb,
+ (void *)d);
event_base_set (d->ev_base, d->ev);
event_add (d->ev, d->tv);
d->in_sendfile = FALSE;
}
# endif
#else
- ssize_t r;
+ ssize_t r;
r = write (d->fd, d->map, d->file_size - d->offset);
if (r == -1) {
if (errno != EAGAIN) {
if (d->err_callback) {
- err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
+ err =
+ g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
+ errno));
d->err_callback (err, d->user_data);
return FALSE;
}
}
else {
- debug_ip("partially write data, retry");
+ debug_ip ("partially write data, retry");
/* Wait for other event */
event_del (d->ev);
event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
}
else if (r + d->offset < d->file_size) {
d->offset += r;
- debug_ip("partially write data, retry");
+ debug_ip ("partially write data, retry");
/* Wait for other event */
event_del (d->ev);
event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
else {
if (d->write_callback) {
if (!d->write_callback (d->user_data)) {
- debug_ip("callback set wanna_die flag, terminating");
+ debug_ip ("callback set wanna_die flag, terminating");
return FALSE;
}
}
event_del (d->ev);
- event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
+ event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb,
+ (void *)d);
event_base_set (d->ev_base, d->ev);
event_add (d->ev, d->tv);
d->in_sendfile = FALSE;
#define BUFREMAIN(x) (x)->data->size - ((x)->pos - (x)->data->begin)
-#define APPEND_OUT_BUFFER(d, buf) do { \
- DL_APPEND((d)->out_buffers.buffers, buf); \
- (d)->out_buffers.pending ++; \
- } while (0)
-#define DELETE_OUT_BUFFER(d, buf) do { \
- DL_DELETE((d)->out_buffers.buffers, (buf)); \
- g_string_free((buf->data), (buf)->allocated); \
- g_slice_free1(sizeof (struct rspamd_out_buffer_s), (buf)); \
- (d)->out_buffers.pending --; \
- } while (0)
-
-static gboolean
+#define APPEND_OUT_BUFFER(d, buf) do { \
+ DL_APPEND ((d)->out_buffers.buffers, buf); \
+ (d)->out_buffers.pending++; \
+} while (0)
+#define DELETE_OUT_BUFFER(d, buf) do { \
+ DL_DELETE ((d)->out_buffers.buffers, (buf)); \
+ g_string_free ((buf->data), (buf)->allocated); \
+ g_slice_free1 (sizeof (struct rspamd_out_buffer_s), (buf)); \
+ (d)->out_buffers.pending--; \
+} while (0)
+
+static gboolean
write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
{
- GError *err = NULL;
- struct rspamd_out_buffer_s *cur = NULL, *tmp;
- ssize_t r;
- struct iovec *iov;
- guint i, len;
+ GError *err = NULL;
+ struct rspamd_out_buffer_s *cur = NULL, *tmp;
+ ssize_t r;
+ struct iovec *iov;
+ guint i, len;
len = d->out_buffers.pending;
while (len > 0) {
is_delayed = TRUE;
iov = g_slice_alloc (len * sizeof (struct iovec));
i = 0;
- DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
+ DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
+ {
iov[i].iov_base = cur->data->str;
iov[i].iov_len = cur->data->len;
- i ++;
+ i++;
}
/* Now try to write the whole vector */
r = writev (fd, iov, len);
if (r == -1 && errno != EAGAIN) {
g_slice_free1 (len * sizeof (struct iovec), iov);
if (d->err_callback) {
- err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
+ err =
+ g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
+ errno));
d->err_callback (err, d->user_data);
return FALSE;
}
}
else if (r > 0) {
/* Find pos inside buffers */
- DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
+ DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
+ {
if (r >= (ssize_t)cur->data->len) {
/* Mark this buffer as read */
r -= cur->data->len;
}
else if (r == -1 && errno == EAGAIN) {
g_slice_free1 (len * sizeof (struct iovec), iov);
- debug_ip("partially write data, retry");
+ debug_ip ("partially write data, retry");
/* Wait for other event */
event_del (d->ev);
event_set (d->ev, fd, EV_WRITE, dispatcher_cb, (void *)d);
if (is_delayed && d->write_callback) {
if (!d->write_callback (d->user_data)) {
- debug_ip("callback set wanna_die flag, terminating");
+ debug_ip ("callback set wanna_die flag, terminating");
return FALSE;
}
}
static void
read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
{
- ssize_t r;
- GError *err = NULL;
- f_str_t res;
- gchar *c, *b;
- gchar *end;
- size_t len;
- enum io_policy saved_policy;
+ ssize_t r;
+ GError *err = NULL;
+ f_str_t res;
+ gchar *c, *b;
+ gchar *end;
+ size_t len;
+ enum io_policy saved_policy;
if (d->wanna_die) {
rspamd_remove_dispatcher (d);
}
if (d->in_buf == NULL) {
- d->in_buf = rspamd_mempool_alloc_tmp (d->pool, sizeof (rspamd_buffer_t));
+ d->in_buf =
+ rspamd_mempool_alloc_tmp (d->pool, sizeof (rspamd_buffer_t));
if (d->policy == BUFFER_LINE || d->policy == BUFFER_ANY) {
d->in_buf->data = fstralloc_tmp (d->pool, d->default_buf_size);
}
r = read (fd, end, BUFREMAIN (d->in_buf));
if (r == -1 && errno != EAGAIN) {
if (d->err_callback) {
- err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
+ err =
+ g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
+ errno));
d->err_callback (err, d->user_data);
return;
}
}
}
else if (r == -1 && errno == EAGAIN) {
- debug_ip("partially read data, retry");
+ debug_ip ("partially read data, retry");
return;
}
else {
d->in_buf->pos += r;
d->in_buf->data->len += r;
}
- debug_ip("read %z characters, policy is %s, watermark is: %z, buffer has %z bytes", r,
- d->policy == BUFFER_LINE ? "LINE" : "CHARACTER", d->nchars, d->in_buf->data->len);
+ debug_ip (
+ "read %z characters, policy is %s, watermark is: %z, buffer has %z bytes",
+ r,
+ d->policy == BUFFER_LINE ? "LINE" : "CHARACTER",
+ d->nchars,
+ d->in_buf->data->len);
}
saved_policy = d->policy;
len = d->in_buf->data->len;
b = c;
r = 0;
-
+
switch (d->policy) {
case BUFFER_LINE:
/** Variables:
- * b - begin of line
- * r - current position in buffer
- * *len - length of remaining buffer
- * c - pointer to current position (buffer->begin + r)
- * res - result string
- */
+ * b - begin of line
+ * r - current position in buffer
+ * *len - length of remaining buffer
+ * c - pointer to current position (buffer->begin + r)
+ * res - result string
+ */
while (r < (ssize_t)len) {
if (*c == '\n') {
res.begin = b;
}
else {
/* Include EOL in reply */
- res.len ++;
+ res.len++;
}
/* Call callback for a line */
if (d->read_callback) {
d->in_buf->pos = d->in_buf->data->begin;
}
if (d->policy != saved_policy && (ssize_t)len != r) {
- debug_ip("policy changed during callback, restart buffer's processing");
+ debug_ip (
+ "policy changed during callback, restart buffer's processing");
read_buffers (fd, d, TRUE);
return;
}
* Actually we do not want to send zero sized
* buffers to a read callback
*/
- if (! (d->want_read && res.len == 0)) {
+ if (!(d->want_read && res.len == 0)) {
if (!d->read_callback (&res, d->user_data)) {
return;
}
}
if (d->policy != saved_policy) {
- debug_ip("policy changed during callback, restart buffer's processing");
+ debug_ip (
+ "policy changed during callback, restart buffer's processing");
read_buffers (fd, d, TRUE);
return;
}
static void
dispatcher_cb (gint fd, short what, void *arg)
{
- rspamd_io_dispatcher_t *d = (rspamd_io_dispatcher_t *) arg;
- GError *err = NULL;
+ rspamd_io_dispatcher_t *d = (rspamd_io_dispatcher_t *) arg;
+ GError *err = NULL;
- debug_ip("in dispatcher callback, what: %d, fd: %d", (gint)what, fd);
+ debug_ip ("in dispatcher callback, what: %d, fd: %d", (gint)what, fd);
if ((what & EV_TIMEOUT) != 0) {
if (d->err_callback) {
else {
/* Want read again */
event_del (d->ev);
- event_set (d->ev, fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
+ event_set (d->ev, fd, EV_READ | EV_PERSIST, dispatcher_cb,
+ (void *)d);
event_base_set (d->ev_base, d->ev);
event_add (d->ev, d->tv);
if (d->is_restored && d->write_callback) {
}
-rspamd_io_dispatcher_t *
-rspamd_create_dispatcher (struct event_base *base, gint fd, enum io_policy policy,
- dispatcher_read_callback_t read_cb, dispatcher_write_callback_t write_cb, dispatcher_err_callback_t err_cb, struct timeval *tv, void *user_data)
+rspamd_io_dispatcher_t *
+rspamd_create_dispatcher (struct event_base *base,
+ gint fd,
+ enum io_policy policy,
+ dispatcher_read_callback_t read_cb,
+ dispatcher_write_callback_t write_cb,
+ dispatcher_err_callback_t err_cb,
+ struct timeval *tv,
+ void *user_data)
{
- rspamd_io_dispatcher_t *new;
+ rspamd_io_dispatcher_t *new;
if (fd == -1) {
return NULL;
struct rspamd_out_buffer_s *cur, *tmp;
if (d != NULL) {
- DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
+ DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
+ {
DELETE_OUT_BUFFER (d, cur);
}
event_del (d->ev);
}
void
-rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d, enum io_policy policy, size_t nchars)
+rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
+ enum io_policy policy,
+ size_t nchars)
{
- f_str_t *tmp;
- gint t;
+ f_str_t *tmp;
+ gint t;
if (d->policy != policy || nchars != d->nchars) {
d->policy = policy;
if (policy == BUFFER_CHARACTER && nchars != 0) {
if (d->in_buf && d->in_buf->data->size < nchars) {
tmp = fstralloc_tmp (d->pool, d->nchars + 1);
- memcpy (tmp->begin, d->in_buf->data->begin, d->in_buf->data->len);
+ memcpy (tmp->begin, d->in_buf->data->begin,
+ d->in_buf->data->len);
t = d->in_buf->pos - d->in_buf->data->begin;
tmp->len = d->in_buf->data->len;
d->in_buf->data = tmp;
else if (policy == BUFFER_LINE || policy == BUFFER_ANY) {
if (d->in_buf && d->nchars < d->default_buf_size) {
tmp = fstralloc_tmp (d->pool, d->default_buf_size);
- memcpy (tmp->begin, d->in_buf->data->begin, d->in_buf->data->len);
+ memcpy (tmp->begin, d->in_buf->data->begin,
+ d->in_buf->data->len);
t = d->in_buf->pos - d->in_buf->data->begin;
tmp->len = d->in_buf->data->len;
d->in_buf->data = tmp;
}
}
- debug_ip("new input length watermark is %uz", d->nchars);
+ debug_ip ("new input length watermark is %uz", d->nchars);
}
gboolean
rspamd_dispatcher_write (rspamd_io_dispatcher_t * d,
- const void *data, size_t len, gboolean delayed, gboolean allocated)
+ const void *data, size_t len, gboolean delayed, gboolean allocated)
{
- struct rspamd_out_buffer_s *newbuf;
+ struct rspamd_out_buffer_s *newbuf;
newbuf = g_slice_alloc (sizeof (struct rspamd_out_buffer_s));
if (len == 0) {
APPEND_OUT_BUFFER (d, newbuf);
if (!delayed) {
- debug_ip("plan write event");
+ debug_ip ("plan write event");
return write_buffers (d->fd, d, FALSE);
}
/* Otherwise plan write event */
return TRUE;
}
-gboolean rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
- GString *str,
- gboolean delayed,
- gboolean free_on_write)
+gboolean
+rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
+ GString *str,
+ gboolean delayed,
+ gboolean free_on_write)
{
- struct rspamd_out_buffer_s *newbuf;
+ struct rspamd_out_buffer_s *newbuf;
newbuf = g_slice_alloc (sizeof (struct rspamd_out_buffer_s));
newbuf->data = str;
APPEND_OUT_BUFFER (d, newbuf);
if (!delayed) {
- debug_ip("plan write event");
+ debug_ip ("plan write event");
return write_buffers (d->fd, d, FALSE);
}
/* Otherwise plan write event */
return TRUE;
}
-gboolean
+gboolean
rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len)
{
if (lseek (fd, 0, SEEK_SET) == -1) {
#ifndef HAVE_SENDFILE
#ifdef HAVE_MMAP_NOCORE
- if ((d->map = mmap (NULL, len, PROT_READ, MAP_SHARED | MAP_NOCORE, fd, 0)) == MAP_FAILED) {
+ if ((d->map =
+ mmap (NULL, len, PROT_READ, MAP_SHARED | MAP_NOCORE, fd,
+ 0)) == MAP_FAILED) {
#else
- if ((d->map = mmap (NULL, len, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((d->map =
+ mmap (NULL, len, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
#endif
msg_warn ("mmap failed: %s", strerror (errno));
return FALSE;
{
struct rspamd_out_buffer_s *cur, *tmp;
- DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
+ DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
+ {
DELETE_OUT_BUFFER (d, cur);
}
/* Cleanup temporary data */
#undef debug_ip
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
#define RSPAMD_BUFFER_H
#include "config.h"
-#include "mem_pool.h"
#include "fstring.h"
+#include "mem_pool.h"
typedef gboolean (*dispatcher_read_callback_t)(f_str_t *in, void *user_data);
typedef gboolean (*dispatcher_write_callback_t)(void *user_data);
* Types of IO handling
*/
enum io_policy {
- BUFFER_LINE, /**< call handler when we have line ready */
- BUFFER_CHARACTER, /**< call handler when we have some characters */
- BUFFER_ANY /**< call handler whenever we got data in buffer */
+ BUFFER_LINE, /**< call handler when we have line ready */
+ BUFFER_CHARACTER, /**< call handler when we have some characters */
+ BUFFER_ANY /**< call handler whenever we got data in buffer */
};
/**
* Buffer structure
*/
typedef struct rspamd_buffer_s {
- f_str_t *data; /**< buffer logic */
- gchar *pos; /**< current position */
+ f_str_t *data; /**< buffer logic */
+ gchar *pos; /**< current position */
} rspamd_buffer_t;
struct rspamd_out_buffer_s {
};
typedef struct rspamd_io_dispatcher_s {
- rspamd_buffer_t *in_buf; /**< input buffer */
+ rspamd_buffer_t *in_buf; /**< input buffer */
struct {
guint pending;
struct rspamd_out_buffer_s *buffers;
- } out_buffers; /**< output buffers chain */
- struct timeval *tv; /**< io timeout */
- struct event *ev; /**< libevent io event */
- rspamd_mempool_t *pool; /**< where to store data */
- enum io_policy policy; /**< IO policy */
- size_t nchars; /**< how many chars to read */
- gint fd; /**< descriptor */
- guint32 peer_addr; /**< address of peer for debugging */
- gboolean wanna_die; /**< if dispatcher should be stopped */
- dispatcher_read_callback_t read_callback; /**< read callback */
- dispatcher_write_callback_t write_callback; /**< write callback */
- dispatcher_err_callback_t err_callback; /**< error callback */
- void *user_data; /**< user's data for callbacks */
- gulong default_buf_size; /**< default size for buffering */
- off_t offset; /**< for sendfile use */
+ } out_buffers; /**< output buffers chain */
+ struct timeval *tv; /**< io timeout */
+ struct event *ev; /**< libevent io event */
+ rspamd_mempool_t *pool; /**< where to store data */
+ enum io_policy policy; /**< IO policy */
+ size_t nchars; /**< how many chars to read */
+ gint fd; /**< descriptor */
+ guint32 peer_addr; /**< address of peer for debugging */
+ gboolean wanna_die; /**< if dispatcher should be stopped */
+ dispatcher_read_callback_t read_callback; /**< read callback */
+ dispatcher_write_callback_t write_callback; /**< write callback */
+ dispatcher_err_callback_t err_callback; /**< error callback */
+ void *user_data; /**< user's data for callbacks */
+ gulong default_buf_size; /**< default size for buffering */
+ off_t offset; /**< for sendfile use */
size_t file_size;
gint sendfile_fd;
- gboolean in_sendfile; /**< whether buffer is in sendfile mode */
- gboolean strip_eol; /**< strip or not line ends in BUFFER_LINE policy */
- gboolean is_restored; /**< call a callback when dispatcher is restored */
- gboolean half_closed; /**< connection is half closed */
- gboolean want_read; /**< whether we want to read more data */
- struct event_base *ev_base; /**< event base for io operations */
+ gboolean in_sendfile; /**< whether buffer is in sendfile mode */
+ gboolean strip_eol; /**< strip or not line ends in BUFFER_LINE policy */
+ gboolean is_restored; /**< call a callback when dispatcher is restored */
+ gboolean half_closed; /**< connection is half closed */
+ gboolean want_read; /**< whether we want to read more data */
+ struct event_base *ev_base; /**< event base for io operations */
#ifndef HAVE_SENDFILE
void *map;
#endif
* @param user_data pointer to user's data
* @return new dispatcher object or NULL in case of failure
*/
-rspamd_io_dispatcher_t* rspamd_create_dispatcher (struct event_base *base, gint fd,
- enum io_policy policy,
- dispatcher_read_callback_t read_cb,
- dispatcher_write_callback_t write_cb,
- dispatcher_err_callback_t err_cb,
- struct timeval *tv,
- void *user_data);
+rspamd_io_dispatcher_t * rspamd_create_dispatcher (struct event_base *base,
+ gint fd,
+ enum io_policy policy,
+ dispatcher_read_callback_t read_cb,
+ dispatcher_write_callback_t write_cb,
+ dispatcher_err_callback_t err_cb,
+ struct timeval *tv,
+ void *user_data);
/**
* Set new policy for dispatcher
* @param policy IO policy
* @param nchars number of characters in buffer for character policy
*/
-void rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t *d,
- enum io_policy policy,
- size_t nchars);
+void rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t *d,
+ enum io_policy policy,
+ size_t nchars);
/**
* Write data when it would be possible
* @param len length of data
*/
gboolean rspamd_dispatcher_write (rspamd_io_dispatcher_t *d,
- const void *data,
- size_t len, gboolean delayed,
- gboolean allocated) G_GNUC_WARN_UNUSED_RESULT;
+ const void *data,
+ size_t len, gboolean delayed,
+ gboolean allocated) G_GNUC_WARN_UNUSED_RESULT;
/**
* Write a GString to dispatcher
* @return TRUE if write has been queued successfully
*/
gboolean rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
- GString *str,
- gboolean delayed,
- gboolean free_on_write) G_GNUC_WARN_UNUSED_RESULT;
+ GString *str,
+ gboolean delayed,
+ gboolean free_on_write) G_GNUC_WARN_UNUSED_RESULT;
/**
* Send specified descriptor to dispatcher
* @param fd descriptor of file
* @param len length of data
*/
-gboolean rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len) G_GNUC_WARN_UNUSED_RESULT;
+gboolean rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d,
+ gint fd,
+ size_t len) G_GNUC_WARN_UNUSED_RESULT;
/**
* Pause IO events on dispatcher
#ifndef CFG_FILE_H
#define CFG_FILE_H
+#include "cfg_rcl.h"
#include "config.h"
#include "mem_pool.h"
-#include "upstream.h"
#include "symbols_cache.h"
-#include "cfg_rcl.h"
-#include "utlist.h"
#include "ucl.h"
+#include "upstream.h"
+#include "utlist.h"
#define DEFAULT_BIND_PORT 11333
#define DEFAULT_CONTROL_PORT 11334
* Regexp structure
*/
struct rspamd_regexp {
- enum rspamd_regexp_type type; /**< regexp type */
- gchar *regexp_text; /**< regexp text representation */
- GRegex *regexp; /**< glib regexp structure */
- GRegex *raw_regexp; /**< glib regexp structure for raw matching */
- gchar *header; /**< header name for header regexps */
- gboolean is_test; /**< true if this expression must be tested */
- gboolean is_raw; /**< true if this regexp is done by raw matching */
- gboolean is_strong; /**< true if headers search must be case sensitive */
+ enum rspamd_regexp_type type; /**< regexp type */
+ gchar *regexp_text; /**< regexp text representation */
+ GRegex *regexp; /**< glib regexp structure */
+ GRegex *raw_regexp; /**< glib regexp structure for raw matching */
+ gchar *header; /**< header name for header regexps */
+ gboolean is_test; /**< true if this expression must be tested */
+ gboolean is_raw; /**< true if this regexp is done by raw matching */
+ gboolean is_strong; /**< true if headers search must be case sensitive */
};
/**
* script module list item
*/
struct script_module {
- gchar *name; /**< name of module */
- gchar *path; /**< path to module */
+ gchar *name; /**< name of module */
+ gchar *path; /**< path to module */
};
/**
* Module option
*/
struct rspamd_module_opt {
- gchar *param; /**< parameter name */
- gchar *value; /**< parameter value */
- gchar *description; /**< parameter description */
- gchar *group; /**< parameter group */
- gpointer actual_data; /**< parsed data */
- gboolean is_lua; /**< actually this is lua variable */
- enum lua_var_type lua_type; /**< type of lua variable */
+ gchar *param; /**< parameter name */
+ gchar *value; /**< parameter value */
+ gchar *description; /**< parameter description */
+ gchar *group; /**< parameter group */
+ gpointer actual_data; /**< parsed data */
+ gboolean is_lua; /**< actually this is lua variable */
+ enum lua_var_type lua_type; /**< type of lua variable */
};
/**
* Statfile section definition
*/
struct rspamd_statfile_section {
- guint32 code; /**< section's code */
- guint64 size; /**< size of section */
- double weight; /**< weight coefficient for section */
+ guint32 code; /**< section's code */
+ guint64 size; /**< size of section */
+ double weight; /**< weight coefficient for section */
};
/**
* Statfile autolearn parameters
*/
struct statfile_autolearn_params {
- const gchar *metric; /**< metric name for autolearn triggering */
- double threshold_min; /**< threshold mark */
- double threshold_max; /**< threshold mark */
- GList *symbols; /**< list of symbols */
+ const gchar *metric; /**< metric name for autolearn triggering */
+ double threshold_min; /**< threshold mark */
+ double threshold_max; /**< threshold mark */
+ GList *symbols; /**< list of symbols */
};
-/**
+/**
* Sync affinity
*/
enum sync_affinity {
guint16 master_port;
};
-typedef double (*statfile_normalize_func)(struct rspamd_config *cfg, long double score, void *params);
+typedef double (*statfile_normalize_func)(struct rspamd_config *cfg,
+ long double score, void *params);
/**
* Statfile config definition
*/
struct rspamd_statfile_config {
- gchar *symbol; /**< symbol of statfile */
- gchar *path; /**< filesystem pattern (with %r or %f) */
- gchar *label; /**< label of this statfile */
- gsize size; /**< size of statfile */
- GList *sections; /**< list of sections in statfile */
- struct statfile_autolearn_params *autolearn; /**< autolearn params */
- struct statfile_binlog_params *binlog; /**< binlog params */
- statfile_normalize_func normalizer; /**< function that is used as normaliser */
- void *normalizer_data; /**< normalizer function params */
- gchar *normalizer_str; /**< source string (for dump) */
- ucl_object_t *opts; /**< other options */
- gboolean is_spam; /**< spam flag */
+ gchar *symbol; /**< symbol of statfile */
+ gchar *path; /**< filesystem pattern (with %r or %f) */
+ gchar *label; /**< label of this statfile */
+ gsize size; /**< size of statfile */
+ GList *sections; /**< list of sections in statfile */
+ struct statfile_autolearn_params *autolearn; /**< autolearn params */
+ struct statfile_binlog_params *binlog; /**< binlog params */
+ statfile_normalize_func normalizer; /**< function that is used as normaliser */
+ void *normalizer_data; /**< normalizer function params */
+ gchar *normalizer_str; /**< source string (for dump) */
+ ucl_object_t *opts; /**< other options */
+ gboolean is_spam; /**< spam flag */
};
/**
* Classifier config definition
*/
struct rspamd_classifier_config {
- GList *statfiles; /**< statfiles list */
- GHashTable *labels; /**< statfiles with labels */
- gchar *metric; /**< metric of this classifier */
- struct classifier *classifier; /**< classifier interface */
- struct tokenizer *tokenizer; /**< tokenizer used for classifier */
- GHashTable *opts; /**< other options */
- GList *pre_callbacks; /**< list of callbacks that are called before classification */
- GList *post_callbacks; /**< list of callbacks that are called after classification */
+ GList *statfiles; /**< statfiles list */
+ GHashTable *labels; /**< statfiles with labels */
+ gchar *metric; /**< metric of this classifier */
+ struct classifier *classifier; /**< classifier interface */
+ struct tokenizer *tokenizer; /**< tokenizer used for classifier */
+ GHashTable *opts; /**< other options */
+ GList *pre_callbacks; /**< list of callbacks that are called before classification */
+ GList *post_callbacks; /**< list of callbacks that are called after classification */
};
struct rspamd_worker_bind_conf {
};
struct rspamd_worker_param_parser {
- rspamd_rcl_handler_t handler; /**< handler function */
- struct rspamd_rcl_struct_parser parser; /**< parser attributes */
- const gchar *name; /**< parameter's name */
- UT_hash_handle hh; /**< hash by name */
+ rspamd_rcl_handler_t handler; /**< handler function */
+ struct rspamd_rcl_struct_parser parser; /**< parser attributes */
+ const gchar *name; /**< parameter's name */
+ UT_hash_handle hh; /**< hash by name */
};
struct rspamd_worker_cfg_parser {
- struct rspamd_worker_param_parser *parsers; /**< parsers hash */
- gint type; /**< workers quark */
- gboolean (*def_obj_parser)(const ucl_object_t *obj, gpointer ud); /**< default object parser */
+ struct rspamd_worker_param_parser *parsers; /**< parsers hash */
+ gint type; /**< workers quark */
+ gboolean (*def_obj_parser)(const ucl_object_t *obj, gpointer ud); /**< default object parser */
gpointer def_ud;
- UT_hash_handle hh; /**< hash by type */
+ UT_hash_handle hh; /**< hash by type */
};
/**
* Config params for rspamd worker
*/
struct rspamd_worker_conf {
- worker_t *worker; /**< pointer to worker type */
- GQuark type; /**< type of worker */
- struct rspamd_worker_bind_conf *bind_conf; /**< bind configuration */
- guint16 count; /**< number of workers */
- GList *listen_socks; /**< listening sockets desctiptors */
- guint32 rlimit_nofile; /**< max files limit */
- guint32 rlimit_maxcore; /**< maximum core file size */
- GHashTable *params; /**< params for worker */
- GQueue *active_workers; /**< linked list of spawned workers */
- gboolean has_socket; /**< whether we should make listening socket in main process */
- gpointer *ctx; /**< worker's context */
- ucl_object_t *options; /**< other worker's options */
+ worker_t *worker; /**< pointer to worker type */
+ GQuark type; /**< type of worker */
+ struct rspamd_worker_bind_conf *bind_conf; /**< bind configuration */
+ guint16 count; /**< number of workers */
+ GList *listen_socks; /**< listening sockets desctiptors */
+ guint32 rlimit_nofile; /**< max files limit */
+ guint32 rlimit_maxcore; /**< maximum core file size */
+ GHashTable *params; /**< params for worker */
+ GQueue *active_workers; /**< linked list of spawned workers */
+ gboolean has_socket; /**< whether we should make listening socket in main process */
+ gpointer *ctx; /**< worker's context */
+ ucl_object_t *options; /**< other worker's options */
};
/**
* Structure that stores all config data
*/
struct rspamd_config {
- gchar *rspamd_user; /**< user to run as */
- gchar *rspamd_group; /**< group to run as */
- rspamd_mempool_t *cfg_pool; /**< memory pool for config */
- gchar *cfg_name; /**< name of config file */
- gchar *pid_file; /**< name of pid file */
- gchar *temp_dir; /**< dir for temp files */
+ gchar *rspamd_user; /**< user to run as */
+ gchar *rspamd_group; /**< group to run as */
+ rspamd_mempool_t *cfg_pool; /**< memory pool for config */
+ gchar *cfg_name; /**< name of config file */
+ gchar *pid_file; /**< name of pid file */
+ gchar *temp_dir; /**< dir for temp files */
#ifdef WITH_GPERF_TOOLS
gchar *profile_path;
#endif
- gboolean no_fork; /**< if 1 do not call daemon() */
- gboolean config_test; /**< if TRUE do only config file test */
- gboolean raw_mode; /**< work in raw mode instead of utf one */
- gboolean one_shot_mode; /**< rules add only one symbol */
- gboolean check_text_attachements; /**< check text attachements as text */
- gboolean convert_config; /**< convert config to XML format */
- gboolean strict_protocol_headers; /**< strictly check protocol headers */
-
- gsize max_diff; /**< maximum diff size for text parts */
-
- enum rspamd_log_type log_type; /**< log type */
- gint log_facility; /**< log facility in case of syslog */
- gint log_level; /**< log level trigger */
- gchar *log_file; /**< path to logfile in case of file logging */
- gboolean log_buffered; /**< whether logging is buffered */
- guint32 log_buf_size; /**< length of log buffer */
- gchar *debug_ip_map; /**< turn on debugging for specified ip addresses */
- gboolean log_urls; /**< whether we should log URLs */
- GList *debug_symbols; /**< symbols to debug */
- gboolean log_color; /**< output colors for console output */
- gboolean log_extended; /**< log extended information */
-
- guint32 statfile_sync_interval; /**< synchronization interval */
- guint32 statfile_sync_timeout; /**< synchronization timeout */
- gboolean mlock_statfile_pool; /**< use mlock (2) for locking statfiles */
-
- gboolean delivery_enable; /**< is delivery agent is enabled */
- gchar *deliver_host; /**< host for mail deliviring */
- struct in_addr deliver_addr; /**< its address */
- guint16 deliver_port; /**< port for deliviring */
- guint16 deliver_family; /**< socket family for delivirnig */
- gchar *deliver_agent_path; /**< deliver to pipe instead of socket */
- gboolean deliver_lmtp; /**< use LMTP instead of SMTP */
-
- GList *script_modules; /**< linked list of script modules to load */
-
- GList *filters; /**< linked list of all filters */
- GList *workers; /**< linked list of all workers params */
- struct rspamd_worker_cfg_parser *wrk_parsers; /**< hash for worker config parsers, indexed by worker quarks */
- gchar *filters_str; /**< string of filters */
- ucl_object_t *rcl_obj; /**< rcl object */
- GHashTable* metrics; /**< hash of metrics indexed by metric name */
- GList* symbols_groups; /**< groups of symbols */
- GList* metrics_list; /**< linked list of metrics */
- GHashTable* metrics_symbols; /**< hash table of metrics indexed by symbol */
- GHashTable* c_modules; /**< hash of c modules indexed by module name */
- GHashTable* composite_symbols; /**< hash of composite symbols indexed by its name */
+ gboolean no_fork; /**< if 1 do not call daemon() */
+ gboolean config_test; /**< if TRUE do only config file test */
+ gboolean raw_mode; /**< work in raw mode instead of utf one */
+ gboolean one_shot_mode; /**< rules add only one symbol */
+ gboolean check_text_attachements; /**< check text attachements as text */
+ gboolean convert_config; /**< convert config to XML format */
+ gboolean strict_protocol_headers; /**< strictly check protocol headers */
+
+ gsize max_diff; /**< maximum diff size for text parts */
+
+ enum rspamd_log_type log_type; /**< log type */
+ gint log_facility; /**< log facility in case of syslog */
+ gint log_level; /**< log level trigger */
+ gchar *log_file; /**< path to logfile in case of file logging */
+ gboolean log_buffered; /**< whether logging is buffered */
+ guint32 log_buf_size; /**< length of log buffer */
+ gchar *debug_ip_map; /**< turn on debugging for specified ip addresses */
+ gboolean log_urls; /**< whether we should log URLs */
+ GList *debug_symbols; /**< symbols to debug */
+ gboolean log_color; /**< output colors for console output */
+ gboolean log_extended; /**< log extended information */
+
+ guint32 statfile_sync_interval; /**< synchronization interval */
+ guint32 statfile_sync_timeout; /**< synchronization timeout */
+ gboolean mlock_statfile_pool; /**< use mlock (2) for locking statfiles */
+
+ gboolean delivery_enable; /**< is delivery agent is enabled */
+ gchar *deliver_host; /**< host for mail deliviring */
+ struct in_addr deliver_addr; /**< its address */
+ guint16 deliver_port; /**< port for deliviring */
+ guint16 deliver_family; /**< socket family for delivirnig */
+ gchar *deliver_agent_path; /**< deliver to pipe instead of socket */
+ gboolean deliver_lmtp; /**< use LMTP instead of SMTP */
+
+ GList *script_modules; /**< linked list of script modules to load */
+
+ GList *filters; /**< linked list of all filters */
+ GList *workers; /**< linked list of all workers params */
+ struct rspamd_worker_cfg_parser *wrk_parsers; /**< hash for worker config parsers, indexed by worker quarks */
+ gchar *filters_str; /**< string of filters */
+ ucl_object_t *rcl_obj; /**< rcl object */
+ GHashTable * metrics; /**< hash of metrics indexed by metric name */
+ GList * symbols_groups; /**< groups of symbols */
+ GList * metrics_list; /**< linked list of metrics */
+ GHashTable * metrics_symbols; /**< hash table of metrics indexed by symbol */
+ GHashTable * c_modules; /**< hash of c modules indexed by module name */
+ GHashTable * composite_symbols; /**< hash of composite symbols indexed by its name */
GList *classifiers; /**< list of all classifiers defined */
GList *statfiles; /**< list of all statfiles in config file order */
GHashTable *classifiers_symbols; /**< hashtable indexed by symbol name of classifiers */
- GHashTable* cfg_params; /**< all cfg params indexed by its name in this structure */
- GList *pre_filters; /**< list of pre-processing lua filters */
- GList *post_filters; /**< list of post-processing lua filters */
- gchar *dynamic_conf; /**< path to dynamic configuration */
- GList *current_dynamic_conf; /**< currently loaded dynamic configuration */
- GHashTable* domain_settings; /**< settings per-domains */
- GHashTable* user_settings; /**< settings per-user */
- gchar* domain_settings_str; /**< string representation of settings */
- gchar* user_settings_str;
- gint clock_res; /**< resolution of clock used */
-
- GList *maps; /**< maps active */
- rspamd_mempool_t *map_pool; /**< static maps pool */
- gdouble map_timeout; /**< maps watch timeout */
-
- struct symbols_cache *cache; /**< symbols cache object */
- gchar *cache_filename; /**< filename of cache file */
- struct metric *default_metric; /**< default metric */
-
- gchar* checksum; /**< real checksum of config file */
- gchar* dump_checksum; /**< dump checksum of config file */
- gpointer lua_state; /**< pointer to lua state */
-
- gchar* rrd_file; /**< rrd file to store statistics */
-
- gchar* history_file; /**< file to save rolling history */
-
- gdouble dns_timeout; /**< timeout in milliseconds for waiting for dns reply */
- guint32 dns_retransmits; /**< maximum retransmits count */
- guint32 dns_throttling_errors; /**< maximum errors for starting resolver throttling */
- guint32 dns_throttling_time; /**< time in seconds for DNS throttling */
- guint32 dns_io_per_server; /**< number of sockets per DNS server */
- GList *nameservers; /**< list of nameservers or NULL to parse resolv.conf */
+ GHashTable * cfg_params; /**< all cfg params indexed by its name in this structure */
+ GList *pre_filters; /**< list of pre-processing lua filters */
+ GList *post_filters; /**< list of post-processing lua filters */
+ gchar *dynamic_conf; /**< path to dynamic configuration */
+ GList *current_dynamic_conf; /**< currently loaded dynamic configuration */
+ GHashTable * domain_settings; /**< settings per-domains */
+ GHashTable * user_settings; /**< settings per-user */
+ gchar * domain_settings_str; /**< string representation of settings */
+ gchar * user_settings_str;
+ gint clock_res; /**< resolution of clock used */
+
+ GList *maps; /**< maps active */
+ rspamd_mempool_t *map_pool; /**< static maps pool */
+ gdouble map_timeout; /**< maps watch timeout */
+
+ struct symbols_cache *cache; /**< symbols cache object */
+ gchar *cache_filename; /**< filename of cache file */
+ struct metric *default_metric; /**< default metric */
+
+ gchar * checksum; /**< real checksum of config file */
+ gchar * dump_checksum; /**< dump checksum of config file */
+ gpointer lua_state; /**< pointer to lua state */
+
+ gchar * rrd_file; /**< rrd file to store statistics */
+
+ gchar * history_file; /**< file to save rolling history */
+
+ gdouble dns_timeout; /**< timeout in milliseconds for waiting for dns reply */
+ guint32 dns_retransmits; /**< maximum retransmits count */
+ guint32 dns_throttling_errors; /**< maximum errors for starting resolver throttling */
+ guint32 dns_throttling_time; /**< time in seconds for DNS throttling */
+ guint32 dns_io_per_server; /**< number of sockets per DNS server */
+ GList *nameservers; /**< list of nameservers or NULL to parse resolv.conf */
};
* @return TRUE if string was parsed
*/
gboolean rspamd_parse_host_port_priority (rspamd_mempool_t *pool,
- const gchar *str, gchar **addr, guint16 *port, guint *priority);
+ const gchar *str, gchar **addr, guint16 *port, guint *priority);
/**
* Parse host:port line
* @return TRUE if string was parsed
*/
gboolean rspamd_parse_host_port (rspamd_mempool_t *pool, const gchar *str,
- gchar **addr, guint16 *port);
+ gchar **addr, guint16 *port);
/**
* Parse host:priority line
* @return TRUE if string was parsed
*/
gboolean rspamd_parse_host_priority (rspamd_mempool_t *pool, const gchar *str,
- gchar **addr, guint *priority);
+ gchar **addr, guint *priority);
/**
* Parse bind credits
* @return 1 if line was successfully parsed and 0 in case of error
*/
gboolean rspamd_parse_bind_line (struct rspamd_config *cfg,
- struct rspamd_worker_conf *cf, const gchar *str);
+ struct rspamd_worker_conf *cf, const gchar *str);
/**
* Init default values
* @param opt_name name of option to get
* @return module value or NULL if option does not defined
*/
-const ucl_object_t* rspamd_config_get_module_opt (struct rspamd_config *cfg,
- const gchar *module_name,
- const gchar *opt_name);
+const ucl_object_t * rspamd_config_get_module_opt (struct rspamd_config *cfg,
+ const gchar *module_name,
+ const gchar *opt_name);
/**
* Parse limit
/*
* Convert comma separated string to a list of strings
*/
-GList* rspamd_config_parse_comma_list (rspamd_mempool_t *pool,
- const gchar *line);
+GList * rspamd_config_parse_comma_list (rspamd_mempool_t *pool,
+ const gchar *line);
/*
* Return a new classifier_config structure, setting default and non-conflicting attributes
*/
-struct rspamd_classifier_config* rspamd_config_new_classifier (struct rspamd_config *cfg,
- struct rspamd_classifier_config *c);
+struct rspamd_classifier_config * rspamd_config_new_classifier (
+ struct rspamd_config *cfg,
+ struct rspamd_classifier_config *c);
/*
* Return a new worker_conf structure, setting default and non-conflicting attributes
*/
-struct rspamd_worker_conf* rspamd_config_new_worker (struct rspamd_config *cfg,
- struct rspamd_worker_conf *c);
+struct rspamd_worker_conf * rspamd_config_new_worker (struct rspamd_config *cfg,
+ struct rspamd_worker_conf *c);
/*
* Return a new metric structure, setting default and non-conflicting attributes
*/
-struct metric* rspamd_config_new_metric (struct rspamd_config *cfg,
- struct metric *c);
+struct metric * rspamd_config_new_metric (struct rspamd_config *cfg,
+ struct metric *c);
/*
* Return a new statfile structure, setting default and non-conflicting attributes
*/
-struct rspamd_statfile_config* rspamd_config_new_statfile (struct rspamd_config *cfg,
- struct rspamd_statfile_config *c);
+struct rspamd_statfile_config * rspamd_config_new_statfile (
+ struct rspamd_config *cfg,
+ struct rspamd_statfile_config *c);
/*
* Read XML configuration file
*/
gboolean rspamd_config_read (struct rspamd_config *cfg,
- const gchar *filename, const gchar *convert_to,
- rspamd_rcl_section_fin_t logger_fin, gpointer logger_ud);
+ const gchar *filename, const gchar *convert_to,
+ rspamd_rcl_section_fin_t logger_fin, gpointer logger_ud);
/*
* Register symbols of classifiers inside metrics
/*
* Find classifier config by name
*/
-struct rspamd_classifier_config* rspamd_config_find_classifier (
- struct rspamd_config *cfg,
- const gchar *name);
+struct rspamd_classifier_config * rspamd_config_find_classifier (
+ struct rspamd_config *cfg,
+ const gchar *name);
/*
* Parse input `ip_list` to radix tree `tree`. Now supports only IPv4 addresses.
*/
gboolean rspamd_config_parse_ip_list (const gchar *ip_list,
- radix_tree_t **tree);
+ radix_tree_t **tree);
#endif /* ifdef CFG_FILE_H */
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "cfg_rcl.h"
-#include "main.h"
#include "cfg_file.h"
-#include "lua/lua_common.h"
-#include "expressions.h"
+#include "cfg_rcl.h"
#include "classifiers/classifiers.h"
+#include "expressions.h"
+#include "lua/lua_common.h"
+#include "main.h"
#include "tokenizers/tokenizers.h"
/*
*/
static gboolean
rspamd_rcl_logging_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
const ucl_object_t *val;
const gchar *facility, *log_type, *log_level;
/* Need to get filename */
val = ucl_object_find_key (obj, "filename");
if (val == NULL || val->type != UCL_STRING) {
- g_set_error (err, CFG_RCL_ERROR, ENOENT, "filename attribute must be specified for file logging type");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ ENOENT,
+ "filename attribute must be specified for file logging type");
return FALSE;
}
cfg->log_type = RSPAMD_LOG_FILE;
- cfg->log_file = rspamd_mempool_strdup (cfg->cfg_pool, ucl_object_tostring (val));
+ cfg->log_file = rspamd_mempool_strdup (cfg->cfg_pool,
+ ucl_object_tostring (val));
}
else if (g_ascii_strcasecmp (log_type, "syslog") == 0) {
/* Need to get facility */
val = ucl_object_find_key (obj, "facility");
if (val != NULL && ucl_object_tostring_safe (val, &facility)) {
if (g_ascii_strcasecmp (facility, "LOG_AUTH") == 0 ||
- g_ascii_strcasecmp (facility, "auth") == 0 ) {
+ g_ascii_strcasecmp (facility, "auth") == 0 ) {
cfg->log_facility = LOG_AUTH;
}
else if (g_ascii_strcasecmp (facility, "LOG_CRON") == 0 ||
- g_ascii_strcasecmp (facility, "cron") == 0 ) {
+ g_ascii_strcasecmp (facility, "cron") == 0 ) {
cfg->log_facility = LOG_CRON;
}
else if (g_ascii_strcasecmp (facility, "LOG_DAEMON") == 0 ||
- g_ascii_strcasecmp (facility, "daemon") == 0 ) {
+ g_ascii_strcasecmp (facility, "daemon") == 0 ) {
cfg->log_facility = LOG_DAEMON;
}
else if (g_ascii_strcasecmp (facility, "LOG_MAIL") == 0 ||
- g_ascii_strcasecmp (facility, "mail") == 0) {
+ g_ascii_strcasecmp (facility, "mail") == 0) {
cfg->log_facility = LOG_MAIL;
}
else if (g_ascii_strcasecmp (facility, "LOG_USER") == 0 ||
- g_ascii_strcasecmp (facility, "user") == 0 ) {
+ g_ascii_strcasecmp (facility, "user") == 0 ) {
cfg->log_facility = LOG_USER;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL0") == 0 ||
- g_ascii_strcasecmp (facility, "local0") == 0) {
+ g_ascii_strcasecmp (facility, "local0") == 0) {
cfg->log_facility = LOG_LOCAL0;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL1") == 0 ||
- g_ascii_strcasecmp (facility, "local1") == 0) {
+ g_ascii_strcasecmp (facility, "local1") == 0) {
cfg->log_facility = LOG_LOCAL1;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL2") == 0 ||
- g_ascii_strcasecmp (facility, "local2") == 0) {
+ g_ascii_strcasecmp (facility, "local2") == 0) {
cfg->log_facility = LOG_LOCAL2;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL3") == 0 ||
- g_ascii_strcasecmp (facility, "local3") == 0) {
+ g_ascii_strcasecmp (facility, "local3") == 0) {
cfg->log_facility = LOG_LOCAL3;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL4") == 0 ||
- g_ascii_strcasecmp (facility, "local4") == 0) {
+ g_ascii_strcasecmp (facility, "local4") == 0) {
cfg->log_facility = LOG_LOCAL4;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL5") == 0 ||
- g_ascii_strcasecmp (facility, "local5") == 0) {
+ g_ascii_strcasecmp (facility, "local5") == 0) {
cfg->log_facility = LOG_LOCAL5;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL6") == 0 ||
- g_ascii_strcasecmp (facility, "local6") == 0) {
+ g_ascii_strcasecmp (facility, "local6") == 0) {
cfg->log_facility = LOG_LOCAL6;
}
else if (g_ascii_strcasecmp (facility, "LOG_LOCAL7") == 0 ||
- g_ascii_strcasecmp (facility, "local7") == 0) {
+ g_ascii_strcasecmp (facility, "local7") == 0) {
cfg->log_facility = LOG_LOCAL7;
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid log facility: %s", facility);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid log facility: %s",
+ facility);
return FALSE;
}
}
}
- else if (g_ascii_strcasecmp (log_type, "stderr") == 0 || g_ascii_strcasecmp (log_type, "console") == 0) {
+ else if (g_ascii_strcasecmp (log_type,
+ "stderr") == 0 || g_ascii_strcasecmp (log_type, "console") == 0) {
cfg->log_type = RSPAMD_LOG_CONSOLE;
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid log type: %s", log_type);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid log type: %s",
+ log_type);
return FALSE;
}
}
else {
/* No type specified */
- msg_warn ("logging type is not specified correctly, log output to the console");
+ msg_warn (
+ "logging type is not specified correctly, log output to the console");
}
/* Handle log level */
cfg->log_level = G_LOG_LEVEL_DEBUG;
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid log level: %s", log_level);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid log level: %s",
+ log_level);
return FALSE;
}
}
static gboolean
rspamd_rcl_options_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
const ucl_object_t *dns;
struct rspamd_rcl_section *dns_section;
dns = ucl_object_find_key (obj, "dns");
if (dns_section != NULL && dns != NULL) {
- if (!rspamd_rcl_section_parse_defaults (dns_section, cfg, dns, cfg, err)) {
+ if (!rspamd_rcl_section_parse_defaults (dns_section, cfg, dns, cfg,
+ err)) {
return FALSE;
}
}
static gint
rspamd_symbols_group_find_func (gconstpointer a, gconstpointer b)
{
- const struct rspamd_symbols_group *gr = a;
- const gchar *uv = b;
+ const struct rspamd_symbols_group *gr = a;
+ const gchar *uv = b;
return g_ascii_strcasecmp (gr->name, uv);
}
*/
static gboolean
rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
- const ucl_object_t *obj, gboolean is_legacy, GError **err)
+ const ucl_object_t *obj, gboolean is_legacy, GError **err)
{
const gchar *group = "ungrouped", *description = NULL, *sym_name;
gdouble symbol_score, *score_ptr;
else if (obj->type == UCL_OBJECT) {
val = ucl_object_find_key (obj, "weight");
if (val == NULL || !ucl_object_todouble_safe (val, &symbol_score)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid symbol score: %s", sym_name);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid symbol score: %s",
+ sym_name);
return FALSE;
}
val = ucl_object_find_key (obj, "description");
}
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid symbol type: %s", sym_name);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid symbol type: %s",
+ sym_name);
return FALSE;
}
- sym_def = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_symbol_def));
+ sym_def =
+ rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_symbol_def));
score_ptr = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (gdouble));
*score_ptr = symbol_score;
g_hash_table_insert (metric->symbols, sym_def->name, score_ptr);
- if ((metric_list = g_hash_table_lookup (cfg->metrics_symbols, sym_def->name)) == NULL) {
+ if ((metric_list =
+ g_hash_table_lookup (cfg->metrics_symbols, sym_def->name)) == NULL) {
metric_list = g_list_prepend (NULL, metric);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_list_free, metric_list);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_list_free,
+ metric_list);
g_hash_table_insert (cfg->metrics_symbols, sym_def->name, metric_list);
}
else {
}
/* Search for symbol group */
- group_list = g_list_find_custom (cfg->symbols_groups, group, rspamd_symbols_group_find_func);
+ group_list = g_list_find_custom (cfg->symbols_groups,
+ group,
+ rspamd_symbols_group_find_func);
if (group_list == NULL) {
/* Create new group */
- sym_group = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_symbols_group));
+ sym_group =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct rspamd_symbols_group));
sym_group->name = rspamd_mempool_strdup (cfg->cfg_pool, group);
sym_group->symbols = NULL;
cfg->symbols_groups = g_list_prepend (cfg->symbols_groups, sym_group);
static gboolean
rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
const ucl_object_t *val, *cur;
const gchar *metric_name, *subject_name, *semicolon, *act_str;
val = ucl_object_find_key (obj, "actions");
if (val != NULL) {
if (val->type != UCL_OBJECT) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "actions must be an object");
+ g_set_error (err, CFG_RCL_ERROR, EINVAL,
+ "actions must be an object");
return FALSE;
}
while ((cur = ucl_iterate_object (val, &it, true)) != NULL) {
if (!check_action_str (ucl_object_key (cur), &action_value) ||
- !ucl_object_todouble_safe (cur, &action_score)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid action definition: %s", ucl_object_key (cur));
+ !ucl_object_todouble_safe (cur, &action_score)) {
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid action definition: %s",
+ ucl_object_key (cur));
return FALSE;
}
action = &metric->actions[action_value];
have_actions = TRUE;
}
val = ucl_object_find_key (obj, "action");
- LL_FOREACH (val, cur) {
+ LL_FOREACH (val, cur)
+ {
if (cur->type == UCL_STRING) {
act_str = ucl_object_tostring (cur);
semicolon = strchr (act_str, ':');
}
}
if (new && !have_actions) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "metric %s has no actions", metric_name);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "metric %s has no actions",
+ metric_name);
return FALSE;
}
}
val = val->value.ov;
}
if (val->type != UCL_OBJECT) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "symbols must be an object");
+ g_set_error (err, CFG_RCL_ERROR, EINVAL,
+ "symbols must be an object");
return FALSE;
}
it = NULL;
val = val->value.ov;
}
if (val->type != UCL_OBJECT) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "symbols must be an object");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "symbols must be an object");
return FALSE;
}
- LL_FOREACH (val, cur) {
+ LL_FOREACH (val, cur)
+ {
if (!rspamd_rcl_insert_symbol (cfg, metric, cur, TRUE, err)) {
return FALSE;
}
}
}
else if (new) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "metric %s has no symbols", metric_name);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "metric %s has no symbols",
+ metric_name);
return FALSE;
}
}
static gboolean
rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
const ucl_object_t *val, *cur;
ucl_object_iter_t it = NULL;
wrk = rspamd_config_new_worker (cfg, NULL);
wrk->worker = rspamd_get_worker_by_type (qtype);
if (wrk->worker == NULL) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "unknown worker type: %s", worker_type);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "unknown worker type: %s",
+ worker_type);
return FALSE;
}
wrk->type = qtype;
}
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "unknown worker type: %s", worker_type);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "unknown worker type: %s",
+ worker_type);
return FALSE;
}
}
if (val->type == UCL_ARRAY) {
val = val->value.ov;
}
- LL_FOREACH (val, cur) {
+ LL_FOREACH (val, cur)
+ {
if (!ucl_object_tostring_safe (cur, &worker_bind)) {
continue;
}
if (!rspamd_parse_bind_line (cfg, wrk, worker_bind)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot parse bind line: %s", worker_bind);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot parse bind line: %s",
+ worker_bind);
return FALSE;
}
}
while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
HASH_FIND_STR (wparser->parsers, ucl_object_key (cur), whandler);
if (whandler != NULL) {
- if (!whandler->handler (cfg, cur, &whandler->parser, section, err)) {
+ if (!whandler->handler (cfg, cur, &whandler->parser, section,
+ err)) {
return FALSE;
}
}
}
if (wparser->def_obj_parser != NULL) {
- if (! wparser->def_obj_parser (obj, wparser->def_ud)) {
+ if (!wparser->def_obj_parser (obj, wparser->def_ud)) {
return FALSE;
}
}
static void
rspamd_rcl_set_lua_globals (struct rspamd_config *cfg, lua_State *L)
{
- struct rspamd_config **pcfg;
+ struct rspamd_config **pcfg;
/* First check for global variable 'config' */
lua_getglobal (L, "config");
static gboolean
rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
- const gchar *lua_src = rspamd_mempool_strdup (cfg->cfg_pool, ucl_object_tostring (obj));
+ const gchar *lua_src = rspamd_mempool_strdup (cfg->cfg_pool,
+ ucl_object_tostring (obj));
gchar *cur_dir, *lua_dir, *lua_file, *tmp1, *tmp2;
lua_State *L = cfg->lua_state;
if (getcwd (cur_dir, PATH_MAX) != NULL && chdir (lua_dir) != -1) {
/* Load file */
if (luaL_loadfile (L, lua_file) != 0) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot load lua file %s: %s",
- lua_src, lua_tostring (L, -1));
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot load lua file %s: %s",
+ lua_src,
+ lua_tostring (L, -1));
if (chdir (cur_dir) == -1) {
- msg_err ("cannot chdir to %s: %s", cur_dir, strerror (errno));;
+ msg_err ("cannot chdir to %s: %s", cur_dir,
+ strerror (errno));;
}
g_free (cur_dir);
g_free (tmp1);
rspamd_rcl_set_lua_globals (cfg, L);
/* Now do it */
if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot init lua file %s: %s",
- lua_src, lua_tostring (L, -1));
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot init lua file %s: %s",
+ lua_src,
+ lua_tostring (L, -1));
if (chdir (cur_dir) == -1) {
- msg_err ("cannot chdir to %s: %s", cur_dir, strerror (errno));;
+ msg_err ("cannot chdir to %s: %s", cur_dir,
+ strerror (errno));;
}
g_free (cur_dir);
g_free (tmp1);
}
else {
g_set_error (err, CFG_RCL_ERROR, ENOENT, "cannot chdir to %s: %s",
- lua_src, strerror (errno));
+ lua_src, strerror (errno));
if (chdir (cur_dir) == -1) {
msg_err ("cannot chdir to %s: %s", cur_dir, strerror (errno));;
}
}
else {
g_set_error (err, CFG_RCL_ERROR, ENOENT, "cannot find to %s: %s",
- lua_src, strerror (errno));
+ lua_src, strerror (errno));
return FALSE;
}
}
static gboolean
-rspamd_rcl_add_module_path (struct rspamd_config *cfg, const gchar *path, GError **err)
+rspamd_rcl_add_module_path (struct rspamd_config *cfg,
+ const gchar *path,
+ GError **err)
{
struct stat st;
struct script_module *cur_mod;
guint i;
if (stat (path, &st) == -1) {
- g_set_error (err, CFG_RCL_ERROR, errno, "cannot stat path %s, %s", path, strerror (errno));
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ errno,
+ "cannot stat path %s, %s",
+ path,
+ strerror (errno));
return FALSE;
}
snprintf (pattern, len, "%s%s", path, "*.lua");
if (glob (pattern, GLOB_DOOFFS, NULL, &globbuf) == 0) {
- for (i = 0; i < globbuf.gl_pathc; i ++) {
- cur_mod = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
- cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool, globbuf.gl_pathv[i]);
- cfg->script_modules = g_list_prepend (cfg->script_modules, cur_mod);
+ for (i = 0; i < globbuf.gl_pathc; i++) {
+ cur_mod =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct script_module));
+ cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool,
+ globbuf.gl_pathv[i]);
+ cfg->script_modules = g_list_prepend (cfg->script_modules,
+ cur_mod);
}
globfree (&globbuf);
g_free (pattern);
}
else {
- g_set_error (err, CFG_RCL_ERROR, errno, "glob failed for %s, %s", pattern, strerror (errno));
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ errno,
+ "glob failed for %s, %s",
+ pattern,
+ strerror (errno));
g_free (pattern);
return FALSE;
}
}
else {
/* Handle single file */
- cur_mod = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
+ cur_mod =
+ rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool, path);
cfg->script_modules = g_list_prepend (cfg->script_modules, cur_mod);
}
static gboolean
rspamd_rcl_modules_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
const ucl_object_t *val, *cur;
const gchar *data;
if (obj->type == UCL_OBJECT) {
val = ucl_object_find_key (obj, "path");
- LL_FOREACH (val, cur) {
+ LL_FOREACH (val, cur)
+ {
if (ucl_object_tostring_safe (cur, &data)) {
- if (!rspamd_rcl_add_module_path (cfg, rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
+ if (!rspamd_rcl_add_module_path (cfg,
+ rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
return FALSE;
}
}
}
}
else if (ucl_object_tostring_safe (obj, &data)) {
- if (!rspamd_rcl_add_module_path (cfg, rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
+ if (!rspamd_rcl_add_module_path (cfg,
+ rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
return FALSE;
}
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "module parameter has wrong type (must be an object or a string)");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "module parameter has wrong type (must be an object or a string)");
return FALSE;
}
static gboolean
rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
struct rspamd_classifier_config *ccf = ud;
const ucl_object_t *val;
val = ucl_object_find_key (obj, "binlog");
if (val != NULL && ucl_object_tostring_safe (val, &data)) {
if (st->binlog == NULL) {
- st->binlog = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct statfile_binlog_params));
+ st->binlog =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct statfile_binlog_params));
}
if (g_ascii_strcasecmp (data, "master") == 0) {
st->binlog->affinity = AFFINITY_MASTER;
}
val = ucl_object_find_key (obj, "binlog_master");
if (val != NULL && ucl_object_tostring_safe (val, &data)) {
- if (!rspamd_parse_host_port (cfg->cfg_pool, data, &st->binlog->master_addr, &st->binlog->master_port)) {
+ if (!rspamd_parse_host_port (cfg->cfg_pool, data,
+ &st->binlog->master_addr, &st->binlog->master_port)) {
msg_err ("cannot parse master address: %s", data);
return FALSE;
}
labels = g_list_append (labels, st);
}
else {
- g_hash_table_insert (ccf->labels, st->label, g_list_prepend (NULL, st));
+ g_hash_table_insert (ccf->labels, st->label,
+ g_list_prepend (NULL, st));
}
}
if (st->symbol != NULL) {
g_hash_table_insert (cfg->classifiers_symbols, st->symbol, st);
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "statfile must have a symbol defined");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "statfile must have a symbol defined");
return FALSE;
}
if (st->path == NULL) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "statfile must have a path defined");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "statfile must have a path defined");
return FALSE;
}
val = ucl_object_find_key (obj, "spam");
if (val == NULL) {
- msg_info ("statfile %s has no explicit 'spam' setting, trying to guess by symbol", st->symbol);
- if (rspamd_strncasestr (st->symbol, "spam", strlen (st->symbol)) != NULL) {
+ msg_info (
+ "statfile %s has no explicit 'spam' setting, trying to guess by symbol",
+ st->symbol);
+ if (rspamd_strncasestr (st->symbol, "spam",
+ strlen (st->symbol)) != NULL) {
st->is_spam = TRUE;
}
- else if (rspamd_strncasestr (st->symbol, "ham", strlen (st->symbol)) != NULL) {
+ else if (rspamd_strncasestr (st->symbol, "ham",
+ strlen (st->symbol)) != NULL) {
st->is_spam = FALSE;
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot guess spam setting from %s", st->symbol);
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot guess spam setting from %s",
+ st->symbol);
return FALSE;
}
- msg_info ("guessed that statfile with symbol %s is %s", st->symbol, st->is_spam ?
- "spam" : "ham");
+ msg_info ("guessed that statfile with symbol %s is %s",
+ st->symbol,
+ st->is_spam ?
+ "spam" : "ham");
}
return TRUE;
}
}
static gboolean
-rspamd_rcl_classifier_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_classifier_handler (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
const ucl_object_t *val, *cur;
ucl_object_iter_t it = NULL;
val = ucl_object_find_key (obj, "type");
if (val == NULL || !ucl_object_tostring_safe (val, &type)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "classifier should have type defined");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "classifier should have type defined");
return FALSE;
}
key = ucl_object_key (val);
if (key != NULL) {
if (g_ascii_strcasecmp (key, "statfile") == 0) {
- LL_FOREACH (val, cur) {
- res = rspamd_rcl_statfile_handler (cfg, cur, ccf, stat_section, err);
+ LL_FOREACH (val, cur)
+ {
+ res = rspamd_rcl_statfile_handler (cfg,
+ cur,
+ ccf,
+ stat_section,
+ err);
if (!res) {
return FALSE;
}
}
}
- else if (g_ascii_strcasecmp (key, "type") == 0 && val->type == UCL_STRING) {
+ else if (g_ascii_strcasecmp (key,
+ "type") == 0 && val->type == UCL_STRING) {
continue;
}
- else if (g_ascii_strcasecmp (key, "tokenizer") == 0 && val->type == UCL_STRING) {
+ else if (g_ascii_strcasecmp (key,
+ "tokenizer") == 0 && val->type == UCL_STRING) {
ccf->tokenizer = get_tokenizer (ucl_object_tostring (val));
}
else {
/* Just insert a value of option to the hash */
- g_hash_table_insert (ccf->opts, (gpointer)key, (gpointer)ucl_object_tostring_forced (val));
+ g_hash_table_insert (ccf->opts,
+ (gpointer)key,
+ (gpointer)ucl_object_tostring_forced (val));
}
}
}
}
static gboolean
-rspamd_rcl_composite_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_composite_handler (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
const ucl_object_t *val;
struct expression *expr;
val = ucl_object_find_key (obj, "name");
if (val == NULL || !ucl_object_tostring_safe (val, &composite_name)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "composite must have a name defined");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "composite must have a name defined");
return FALSE;
}
val = ucl_object_find_key (obj, "expression");
if (val == NULL || !ucl_object_tostring_safe (val, &composite_expression)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "composite must have an expression defined");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "composite must have an expression defined");
return FALSE;
}
- if ((expr = parse_expression (cfg->cfg_pool, (gchar *)composite_expression)) == NULL) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot parse composite expression: %s", composite_expression);
+ if ((expr =
+ parse_expression (cfg->cfg_pool,
+ (gchar *)composite_expression)) == NULL) {
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot parse composite expression: %s",
+ composite_expression);
return FALSE;
}
- composite = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_composite));
+ composite =
+ rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_composite));
composite->expr = expr;
composite->id = g_hash_table_size (cfg->composite_symbols) + 1;
- g_hash_table_insert (cfg->composite_symbols, (gpointer)composite_name, composite);
+ g_hash_table_insert (cfg->composite_symbols,
+ (gpointer)composite_name,
+ composite);
if (new) {
register_virtual_symbol (&cfg->cache, composite_name, 1);
*/
static gboolean
rspamd_rcl_empty_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+ gpointer ud, struct rspamd_rcl_section *section, GError **err)
{
return rspamd_rcl_section_parse_defaults (section, cfg, obj, cfg, err);
}
* @param strict_type turn on strict check for types for this section
* @return newly created structure
*/
-static inline struct rspamd_rcl_section*
+static inline struct rspamd_rcl_section *
rspamd_rcl_add_section (struct rspamd_rcl_section **top,
- const gchar *name, rspamd_rcl_handler_t handler,
- enum ucl_type type, gboolean required, gboolean strict_type)
+ const gchar *name, rspamd_rcl_handler_t handler,
+ enum ucl_type type, gboolean required, gboolean strict_type)
{
struct rspamd_rcl_section *new;
* @return newly created structure
*/
static inline struct rspamd_rcl_default_handler_data *
-rspamd_rcl_add_default_handler (struct rspamd_rcl_section *section, const gchar *name,
- rspamd_rcl_handler_t handler, gsize offset, gint flags)
+rspamd_rcl_add_default_handler (struct rspamd_rcl_section *section,
+ const gchar *name,
+ rspamd_rcl_handler_t handler,
+ gsize offset,
+ gint flags)
{
struct rspamd_rcl_default_handler_data *new;
new->pd.offset = offset;
new->pd.flags = flags;
- HASH_ADD_KEYPTR (hh, section->default_parser, new->key, strlen (new->key), new);
+ HASH_ADD_KEYPTR (hh, section->default_parser, new->key, strlen (
+ new->key), new);
return new;
}
-struct rspamd_rcl_section*
+struct rspamd_rcl_section *
rspamd_rcl_config_init (void)
{
struct rspamd_rcl_section *new = NULL, *sub, *ssub;
/**
* Logging section
*/
- sub = rspamd_rcl_add_section (&new, "logging", rspamd_rcl_logging_handler, UCL_OBJECT,
- FALSE, TRUE);
+ sub = rspamd_rcl_add_section (&new,
+ "logging",
+ rspamd_rcl_logging_handler,
+ UCL_OBJECT,
+ FALSE,
+ TRUE);
/* Default handlers */
- rspamd_rcl_add_default_handler (sub, "log_buffer", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_config, log_buf_size), 0);
- rspamd_rcl_add_default_handler (sub, "log_urls", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, log_urls), 0);
- rspamd_rcl_add_default_handler (sub, "debug_ip", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, debug_ip_map), 0);
- rspamd_rcl_add_default_handler (sub, "debug_symbols", rspamd_rcl_parse_struct_string_list,
- G_STRUCT_OFFSET (struct rspamd_config, debug_symbols), 0);
- rspamd_rcl_add_default_handler (sub, "log_color", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, log_color), 0);
+ rspamd_rcl_add_default_handler (sub,
+ "log_buffer",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_config, log_buf_size),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "log_urls",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, log_urls),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "debug_ip",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, debug_ip_map),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "debug_symbols",
+ rspamd_rcl_parse_struct_string_list,
+ G_STRUCT_OFFSET (struct rspamd_config, debug_symbols),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "log_color",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, log_color),
+ 0);
/**
* Options section
*/
- sub = rspamd_rcl_add_section (&new, "options", rspamd_rcl_options_handler, UCL_OBJECT,
- FALSE, TRUE);
- rspamd_rcl_add_default_handler (sub, "cache_file", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, cache_filename), RSPAMD_CL_FLAG_STRING_PATH);
+ sub = rspamd_rcl_add_section (&new,
+ "options",
+ rspamd_rcl_options_handler,
+ UCL_OBJECT,
+ FALSE,
+ TRUE);
+ rspamd_rcl_add_default_handler (sub,
+ "cache_file",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, cache_filename),
+ RSPAMD_CL_FLAG_STRING_PATH);
/* Old DNS configuration */
- rspamd_rcl_add_default_handler (sub, "dns_nameserver", rspamd_rcl_parse_struct_string_list,
- G_STRUCT_OFFSET (struct rspamd_config, nameservers), 0);
- rspamd_rcl_add_default_handler (sub, "dns_timeout", rspamd_rcl_parse_struct_time,
- G_STRUCT_OFFSET (struct rspamd_config, dns_timeout), RSPAMD_CL_FLAG_TIME_FLOAT);
- rspamd_rcl_add_default_handler (sub, "dns_retransmits", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_config, dns_retransmits), RSPAMD_CL_FLAG_INT_32);
- rspamd_rcl_add_default_handler (sub, "dns_sockets", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_add_default_handler (sub,
+ "dns_nameserver",
+ rspamd_rcl_parse_struct_string_list,
+ G_STRUCT_OFFSET (struct rspamd_config, nameservers),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "dns_timeout",
+ rspamd_rcl_parse_struct_time,
+ G_STRUCT_OFFSET (struct rspamd_config, dns_timeout),
+ RSPAMD_CL_FLAG_TIME_FLOAT);
+ rspamd_rcl_add_default_handler (sub,
+ "dns_retransmits",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_config, dns_retransmits),
+ RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_add_default_handler (sub,
+ "dns_sockets",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server),
+ RSPAMD_CL_FLAG_INT_32);
/* New DNS configiration */
ssub = rspamd_rcl_add_section (&sub->subsections, "dns", NULL,
- UCL_OBJECT, FALSE, TRUE);
- rspamd_rcl_add_default_handler (ssub, "nameserver", rspamd_rcl_parse_struct_string_list,
- G_STRUCT_OFFSET (struct rspamd_config, nameservers), 0);
- rspamd_rcl_add_default_handler (ssub, "timeout", rspamd_rcl_parse_struct_time,
- G_STRUCT_OFFSET (struct rspamd_config, dns_timeout), RSPAMD_CL_FLAG_TIME_FLOAT);
- rspamd_rcl_add_default_handler (ssub, "retransmits", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_config, dns_retransmits), RSPAMD_CL_FLAG_INT_32);
- rspamd_rcl_add_default_handler (ssub, "sockets", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server), RSPAMD_CL_FLAG_INT_32);
-
- rspamd_rcl_add_default_handler (sub, "raw_mode", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, raw_mode), 0);
- rspamd_rcl_add_default_handler (sub, "one_shot", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, one_shot_mode), 0);
- rspamd_rcl_add_default_handler (sub, "check_attachements", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, check_text_attachements), 0);
- rspamd_rcl_add_default_handler (sub, "tempdir", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, temp_dir), RSPAMD_CL_FLAG_STRING_PATH);
- rspamd_rcl_add_default_handler (sub, "pidfile", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, pid_file), RSPAMD_CL_FLAG_STRING_PATH);
- rspamd_rcl_add_default_handler (sub, "filters", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, filters_str), 0);
- rspamd_rcl_add_default_handler (sub, "sync_interval", rspamd_rcl_parse_struct_time,
- G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_interval), RSPAMD_CL_FLAG_TIME_INTEGER);
- rspamd_rcl_add_default_handler (sub, "sync_timeout", rspamd_rcl_parse_struct_time,
- G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
- rspamd_rcl_add_default_handler (sub, "max_diff", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_config, max_diff), RSPAMD_CL_FLAG_INT_SIZE);
- rspamd_rcl_add_default_handler (sub, "map_watch_interval", rspamd_rcl_parse_struct_time,
- G_STRUCT_OFFSET (struct rspamd_config, map_timeout), RSPAMD_CL_FLAG_TIME_FLOAT);
- rspamd_rcl_add_default_handler (sub, "dynamic_conf", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, dynamic_conf), 0);
+ UCL_OBJECT, FALSE, TRUE);
+ rspamd_rcl_add_default_handler (ssub,
+ "nameserver",
+ rspamd_rcl_parse_struct_string_list,
+ G_STRUCT_OFFSET (struct rspamd_config, nameservers),
+ 0);
+ rspamd_rcl_add_default_handler (ssub,
+ "timeout",
+ rspamd_rcl_parse_struct_time,
+ G_STRUCT_OFFSET (struct rspamd_config, dns_timeout),
+ RSPAMD_CL_FLAG_TIME_FLOAT);
+ rspamd_rcl_add_default_handler (ssub,
+ "retransmits",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_config, dns_retransmits),
+ RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_add_default_handler (ssub,
+ "sockets",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server),
+ RSPAMD_CL_FLAG_INT_32);
+
+ rspamd_rcl_add_default_handler (sub,
+ "raw_mode",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, raw_mode),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "one_shot",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, one_shot_mode),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "check_attachements",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, check_text_attachements),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "tempdir",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, temp_dir),
+ RSPAMD_CL_FLAG_STRING_PATH);
+ rspamd_rcl_add_default_handler (sub,
+ "pidfile",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, pid_file),
+ RSPAMD_CL_FLAG_STRING_PATH);
+ rspamd_rcl_add_default_handler (sub,
+ "filters",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, filters_str),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "sync_interval",
+ rspamd_rcl_parse_struct_time,
+ G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_interval),
+ RSPAMD_CL_FLAG_TIME_INTEGER);
+ rspamd_rcl_add_default_handler (sub,
+ "sync_timeout",
+ rspamd_rcl_parse_struct_time,
+ G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_timeout),
+ RSPAMD_CL_FLAG_TIME_INTEGER);
+ rspamd_rcl_add_default_handler (sub,
+ "max_diff",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_config, max_diff),
+ RSPAMD_CL_FLAG_INT_SIZE);
+ rspamd_rcl_add_default_handler (sub,
+ "map_watch_interval",
+ rspamd_rcl_parse_struct_time,
+ G_STRUCT_OFFSET (struct rspamd_config, map_timeout),
+ RSPAMD_CL_FLAG_TIME_FLOAT);
+ rspamd_rcl_add_default_handler (sub,
+ "dynamic_conf",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, dynamic_conf),
+ 0);
rspamd_rcl_add_default_handler (sub, "rrd", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, rrd_file), RSPAMD_CL_FLAG_STRING_PATH);
- rspamd_rcl_add_default_handler (sub, "history_file", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_config, history_file), RSPAMD_CL_FLAG_STRING_PATH);
- rspamd_rcl_add_default_handler (sub, "use_mlock", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, mlock_statfile_pool), 0);
- rspamd_rcl_add_default_handler (sub, "strict_protocol_headers", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_config, strict_protocol_headers), 0);
+ G_STRUCT_OFFSET (struct rspamd_config,
+ rrd_file), RSPAMD_CL_FLAG_STRING_PATH);
+ rspamd_rcl_add_default_handler (sub,
+ "history_file",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_config, history_file),
+ RSPAMD_CL_FLAG_STRING_PATH);
+ rspamd_rcl_add_default_handler (sub,
+ "use_mlock",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, mlock_statfile_pool),
+ 0);
+ rspamd_rcl_add_default_handler (sub,
+ "strict_protocol_headers",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_config, strict_protocol_headers),
+ 0);
/**
* Metric section
*/
- sub = rspamd_rcl_add_section (&new, "metric", rspamd_rcl_metric_handler, UCL_OBJECT,
- FALSE, TRUE);
+ sub = rspamd_rcl_add_section (&new,
+ "metric",
+ rspamd_rcl_metric_handler,
+ UCL_OBJECT,
+ FALSE,
+ TRUE);
/**
* Worker section
*/
- sub = rspamd_rcl_add_section (&new, "worker", rspamd_rcl_worker_handler, UCL_OBJECT,
- FALSE, TRUE);
- rspamd_rcl_add_default_handler (sub, "count", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_worker_conf, count), RSPAMD_CL_FLAG_INT_16);
- rspamd_rcl_add_default_handler (sub, "max_files", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_worker_conf, rlimit_nofile), RSPAMD_CL_FLAG_INT_32);
- rspamd_rcl_add_default_handler (sub, "max_core", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_worker_conf, rlimit_maxcore), RSPAMD_CL_FLAG_INT_32);
+ sub = rspamd_rcl_add_section (&new,
+ "worker",
+ rspamd_rcl_worker_handler,
+ UCL_OBJECT,
+ FALSE,
+ TRUE);
+ rspamd_rcl_add_default_handler (sub,
+ "count",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_worker_conf, count),
+ RSPAMD_CL_FLAG_INT_16);
+ rspamd_rcl_add_default_handler (sub,
+ "max_files",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_worker_conf, rlimit_nofile),
+ RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_add_default_handler (sub,
+ "max_core",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_worker_conf, rlimit_maxcore),
+ RSPAMD_CL_FLAG_INT_32);
/**
* Lua handler
*/
- sub = rspamd_rcl_add_section (&new, "lua", rspamd_rcl_lua_handler, UCL_STRING,
- FALSE, TRUE);
+ sub = rspamd_rcl_add_section (&new,
+ "lua",
+ rspamd_rcl_lua_handler,
+ UCL_STRING,
+ FALSE,
+ TRUE);
/**
* Modules handler
*/
- sub = rspamd_rcl_add_section (&new, "modules", rspamd_rcl_modules_handler, UCL_OBJECT,
- FALSE, FALSE);
+ sub = rspamd_rcl_add_section (&new,
+ "modules",
+ rspamd_rcl_modules_handler,
+ UCL_OBJECT,
+ FALSE,
+ FALSE);
/**
* Classifiers handler
*/
- sub = rspamd_rcl_add_section (&new, "classifier", rspamd_rcl_classifier_handler, UCL_OBJECT,
- FALSE, TRUE);
- ssub = rspamd_rcl_add_section (&sub->subsections, "statfile", rspamd_rcl_statfile_handler,
- UCL_OBJECT, TRUE, TRUE);
- rspamd_rcl_add_default_handler (ssub, "symbol", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_statfile_config, symbol), 0);
- rspamd_rcl_add_default_handler (ssub, "path", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_statfile_config, path), RSPAMD_CL_FLAG_STRING_PATH);
- rspamd_rcl_add_default_handler (ssub, "label", rspamd_rcl_parse_struct_string,
- G_STRUCT_OFFSET (struct rspamd_statfile_config, label), 0);
- rspamd_rcl_add_default_handler (ssub, "size", rspamd_rcl_parse_struct_integer,
- G_STRUCT_OFFSET (struct rspamd_statfile_config, size), RSPAMD_CL_FLAG_INT_SIZE);
- rspamd_rcl_add_default_handler (ssub, "spam", rspamd_rcl_parse_struct_boolean,
- G_STRUCT_OFFSET (struct rspamd_statfile_config, is_spam), 0);
+ sub = rspamd_rcl_add_section (&new,
+ "classifier",
+ rspamd_rcl_classifier_handler,
+ UCL_OBJECT,
+ FALSE,
+ TRUE);
+ ssub = rspamd_rcl_add_section (&sub->subsections,
+ "statfile",
+ rspamd_rcl_statfile_handler,
+ UCL_OBJECT,
+ TRUE,
+ TRUE);
+ rspamd_rcl_add_default_handler (ssub,
+ "symbol",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_statfile_config, symbol),
+ 0);
+ rspamd_rcl_add_default_handler (ssub,
+ "path",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_statfile_config, path),
+ RSPAMD_CL_FLAG_STRING_PATH);
+ rspamd_rcl_add_default_handler (ssub,
+ "label",
+ rspamd_rcl_parse_struct_string,
+ G_STRUCT_OFFSET (struct rspamd_statfile_config, label),
+ 0);
+ rspamd_rcl_add_default_handler (ssub,
+ "size",
+ rspamd_rcl_parse_struct_integer,
+ G_STRUCT_OFFSET (struct rspamd_statfile_config, size),
+ RSPAMD_CL_FLAG_INT_SIZE);
+ rspamd_rcl_add_default_handler (ssub,
+ "spam",
+ rspamd_rcl_parse_struct_boolean,
+ G_STRUCT_OFFSET (struct rspamd_statfile_config, is_spam),
+ 0);
/**
* Composites handler
*/
- sub = rspamd_rcl_add_section (&new, "composite", rspamd_rcl_composite_handler, UCL_OBJECT,
- FALSE, TRUE);
+ sub = rspamd_rcl_add_section (&new,
+ "composite",
+ rspamd_rcl_composite_handler,
+ UCL_OBJECT,
+ FALSE,
+ TRUE);
return new;
}
struct rspamd_rcl_section *
rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
- const char *path)
+ const char *path)
{
struct rspamd_rcl_section *cur, *found;
char **path_components;
ncomponents = g_strv_length (path_components);
cur = top;
- for (i = 0; i < ncomponents; i ++) {
+ for (i = 0; i < ncomponents; i++) {
if (cur == NULL) {
g_strfreev (path_components);
return NULL;
gboolean
rspamd_read_rcl_config (struct rspamd_rcl_section *top,
- struct rspamd_config *cfg, const ucl_object_t *obj, GError **err)
+ struct rspamd_config *cfg, const ucl_object_t *obj, GError **err)
{
const ucl_object_t *found, *cur_obj;
struct rspamd_rcl_section *cur, *tmp;
if (obj->type != UCL_OBJECT) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "top configuration must be an object");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "top configuration must be an object");
return FALSE;
}
/* Iterate over known sections and ignore unknown ones */
- HASH_ITER (hh, top, cur, tmp) {
+ HASH_ITER (hh, top, cur, tmp)
+ {
found = ucl_object_find_key (obj, cur->name);
if (found == NULL) {
if (cur->required) {
g_set_error (err, CFG_RCL_ERROR, ENOENT,
- "required section %s is missing", cur->name);
+ "required section %s is missing", cur->name);
return FALSE;
}
}
if (cur->strict_type) {
if (cur->type != found->type) {
g_set_error (err, CFG_RCL_ERROR, EINVAL,
- "object in section %s has invalid type", cur->name);
+ "object in section %s has invalid type", cur->name);
return FALSE;
}
}
- LL_FOREACH (found, cur_obj) {
+ LL_FOREACH (found, cur_obj)
+ {
if (cur->handler != NULL) {
if (!cur->handler (cfg, cur_obj, NULL, cur, err)) {
return FALSE;
}
}
else {
- rspamd_rcl_section_parse_defaults (cur, cfg, cur_obj, cfg, err);
+ rspamd_rcl_section_parse_defaults (cur,
+ cfg,
+ cur_obj,
+ cfg,
+ err);
}
}
}
return TRUE;
}
-gboolean rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
- struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
- GError **err)
+gboolean
+rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
+ struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
+ GError **err)
{
const ucl_object_t *found;
struct rspamd_rcl_default_handler_data *cur, *tmp;
if (obj->type != UCL_OBJECT) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "default configuration must be an object");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "default configuration must be an object");
return FALSE;
}
- HASH_ITER (hh, section->default_parser, cur, tmp) {
+ HASH_ITER (hh, section->default_parser, cur, tmp)
+ {
found = ucl_object_find_key (obj, cur->key);
if (found != NULL) {
cur->pd.user_struct = ptr;
}
gboolean
-rspamd_rcl_parse_struct_string (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
struct rspamd_rcl_struct_parser *pd = ud;
gchar **target;
target = (gchar **)(((gchar *)pd->user_struct) + pd->offset);
switch (obj->type) {
case UCL_STRING:
- *target = rspamd_mempool_strdup (cfg->cfg_pool, ucl_copy_value_trash (obj));
+ *target =
+ rspamd_mempool_strdup (cfg->cfg_pool, ucl_copy_value_trash (obj));
break;
case UCL_INT:
*target = rspamd_mempool_alloc (cfg->cfg_pool, num_str_len);
rspamd_snprintf (*target, num_str_len, "%b", (gboolean)obj->value.iv);
break;
default:
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert object or array to string");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert object or array to string");
return FALSE;
}
}
gboolean
-rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
struct rspamd_rcl_struct_parser *pd = ud;
union {
if (pd->flags == RSPAMD_CL_FLAG_INT_32) {
target.i32p = (gint32 *)(((gchar *)pd->user_struct) + pd->offset);
if (!ucl_object_toint_safe (obj, &val)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to integer");
return FALSE;
}
*target.i32p = val;
else if (pd->flags == RSPAMD_CL_FLAG_INT_64) {
target.i64p = (gint64 *)(((gchar *)pd->user_struct) + pd->offset);
if (!ucl_object_toint_safe (obj, &val)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to integer");
return FALSE;
}
*target.i64p = val;
else if (pd->flags == RSPAMD_CL_FLAG_INT_SIZE) {
target.sp = (gsize *)(((gchar *)pd->user_struct) + pd->offset);
if (!ucl_object_toint_safe (obj, &val)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to integer");
return FALSE;
}
*target.sp = val;
else if (pd->flags == RSPAMD_CL_FLAG_INT_16) {
target.i16p = (gint16 *)(((gchar *)pd->user_struct) + pd->offset);
if (!ucl_object_toint_safe (obj, &val)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to integer");
return FALSE;
}
*target.i16p = val;
else {
target.ip = (gint *)(((gchar *)pd->user_struct) + pd->offset);
if (!ucl_object_toint_safe (obj, &val)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to integer");
return FALSE;
}
*target.ip = val;
}
gboolean
-rspamd_rcl_parse_struct_double (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
struct rspamd_rcl_struct_parser *pd = ud;
gdouble *target;
target = (gdouble *)(((gchar *)pd->user_struct) + pd->offset);
if (!ucl_object_todouble_safe (obj, target)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to double");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to double");
return FALSE;
}
}
gboolean
-rspamd_rcl_parse_struct_time (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
struct rspamd_rcl_struct_parser *pd = ud;
union {
gdouble val;
if (!ucl_object_todouble_safe (obj, &val)) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to double");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert param to double");
return FALSE;
}
if (pd->flags == RSPAMD_CL_FLAG_TIME_TIMEVAL) {
- target.ptv = (struct timeval *)(((gchar *)pd->user_struct) + pd->offset);
+ target.ptv =
+ (struct timeval *)(((gchar *)pd->user_struct) + pd->offset);
target.ptv->tv_sec = (glong)val;
target.ptv->tv_usec = (val - (glong)val) * 1000000;
}
else if (pd->flags == RSPAMD_CL_FLAG_TIME_TIMESPEC) {
- target.pts = (struct timespec *)(((gchar *)pd->user_struct) + pd->offset);
+ target.pts =
+ (struct timespec *)(((gchar *)pd->user_struct) + pd->offset);
target.pts->tv_sec = (glong)val;
target.pts->tv_nsec = (val - (glong)val) * 1000000000000LL;
}
*target.pu32 = val * 1000;
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid flags to parse time value");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "invalid flags to parse time value");
return FALSE;
}
}
gboolean
-rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
struct rspamd_rcl_struct_parser *pd = ud;
GList **target;
target = (GList **)(((gchar *)pd->user_struct) + pd->offset);
if (obj->type != UCL_ARRAY) {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "an array of strings is expected");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "an array of strings is expected");
return FALSE;
}
while ((cur = ucl_iterate_object (obj, &iter, true)) != NULL) {
switch (cur->type) {
case UCL_STRING:
- val = rspamd_mempool_strdup (cfg->cfg_pool, ucl_copy_value_trash (cur));
+ val =
+ rspamd_mempool_strdup (cfg->cfg_pool,
+ ucl_copy_value_trash (cur));
break;
case UCL_INT:
val = rspamd_mempool_alloc (cfg->cfg_pool, num_str_len);
rspamd_snprintf (val, num_str_len, "%b", (gboolean)cur->value.iv);
break;
default:
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert an object or array to string");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert an object or array to string");
return FALSE;
}
*target = g_list_prepend (*target, val);
}
/* Add a destructor */
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_list_free, *target);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_list_free,
+ *target);
return TRUE;
}
gboolean
-rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err)
{
struct rspamd_rcl_struct_parser *pd = ud;
gboolean *target;
*target = obj->value.iv;
}
else {
- g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert an object to boolean");
+ g_set_error (err,
+ CFG_RCL_ERROR,
+ EINVAL,
+ "cannot convert an object to boolean");
return FALSE;
}
}
void
-rspamd_rcl_register_worker_option (struct rspamd_config *cfg, gint type, const gchar *name,
- rspamd_rcl_handler_t handler, gpointer target, gsize offset, gint flags)
+rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
+ gint type,
+ const gchar *name,
+ rspamd_rcl_handler_t handler,
+ gpointer target,
+ gsize offset,
+ gint flags)
{
struct rspamd_worker_param_parser *nhandler;
struct rspamd_worker_cfg_parser *nparser;
HASH_FIND_INT (cfg->wrk_parsers, &type, nparser);
if (nparser == NULL) {
/* Allocate new parser for this worker */
- nparser = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_cfg_parser));
+ nparser =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_worker_cfg_parser));
nparser->type = type;
HASH_ADD_INT (cfg->wrk_parsers, type, nparser);
}
HASH_FIND_STR (nparser->parsers, name, nhandler);
if (nhandler != NULL) {
- msg_warn ("handler for parameter %s is already registered for worker type %s",
- name, g_quark_to_string (type));
+ msg_warn (
+ "handler for parameter %s is already registered for worker type %s",
+ name,
+ g_quark_to_string (type));
return;
}
- nhandler = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_param_parser));
+ nhandler =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_worker_param_parser));
nhandler->name = name;
nhandler->parser.flags = flags;
nhandler->parser.offset = offset;
void
rspamd_rcl_register_worker_parser (struct rspamd_config *cfg, gint type,
- gboolean (*func)(ucl_object_t *, gpointer), gpointer ud)
+ gboolean (*func)(ucl_object_t *, gpointer), gpointer ud)
{
struct rspamd_worker_cfg_parser *nparser;
HASH_FIND_INT (cfg->wrk_parsers, &type, nparser);
if (nparser == NULL) {
/* Allocate new parser for this worker */
- nparser = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_cfg_parser));
+ nparser =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_worker_cfg_parser));
nparser->type = type;
HASH_ADD_INT (cfg->wrk_parsers, type, nparser);
}
* @param err error object
* @return TRUE if a section has been parsed
*/
-typedef gboolean (*rspamd_rcl_handler_t) (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+typedef gboolean (*rspamd_rcl_handler_t) (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud, struct rspamd_rcl_section *section, GError **err);
/**
* A handler type that is called at the end of section parsing
* @param cfg configuration
* @param ud user data
*/
-typedef void (*rspamd_rcl_section_fin_t)(struct rspamd_config *cfg, gpointer ud);
+typedef void (*rspamd_rcl_section_fin_t)(struct rspamd_config *cfg,
+ gpointer ud);
struct rspamd_rcl_default_handler_data {
struct rspamd_rcl_struct_parser pd;
};
struct rspamd_rcl_section {
- const gchar *name; /**< name of section */
- rspamd_rcl_handler_t handler; /**< handler of section attributes */
- enum ucl_type type; /**< type of attribute */
- gboolean required; /**< whether this param is required */
- gboolean strict_type; /**< whether we need strict type */
- UT_hash_handle hh; /** hash handle */
+ const gchar *name; /**< name of section */
+ rspamd_rcl_handler_t handler; /**< handler of section attributes */
+ enum ucl_type type; /**< type of attribute */
+ gboolean required; /**< whether this param is required */
+ gboolean strict_type; /**< whether we need strict type */
+ UT_hash_handle hh; /** hash handle */
struct rspamd_rcl_section *subsections; /**< hash table of subsections */
struct rspamd_rcl_default_handler_data *default_parser; /**< generic parsing fields */
rspamd_rcl_section_fin_t fin; /** called at the end of section parsing */
* Init common sections known to rspamd
* @return top section
*/
-struct rspamd_rcl_section* rspamd_rcl_config_init (void);
+struct rspamd_rcl_section * rspamd_rcl_config_init (void);
/**
* Get a section specified by path, it understand paths separated by '/' character
* @param path '/' divided path
* @return
*/
-struct rspamd_rcl_section *rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
- const char *path);
+struct rspamd_rcl_section * rspamd_rcl_config_get_section (
+ struct rspamd_rcl_section *top,
+ const char *path);
/**
* Read RCL configuration and parse it to a config file
* @return TRUE if an object can be parsed
*/
gboolean rspamd_read_rcl_config (struct rspamd_rcl_section *top,
- struct rspamd_config *cfg, const ucl_object_t *obj, GError **err);
+ struct rspamd_config *cfg, const ucl_object_t *obj, GError **err);
/**
* @return TRUE if the object has been parsed
*/
gboolean rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
- struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
- GError **err);
+ struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
+ GError **err);
/**
* Here is a section of common handlers that accepts rcl_struct_parser
* which itself contains a struct pointer and the offset of a member in a
* @param err error pointer
* @return TRUE if a string value has been successfully parsed
*/
-gboolean rspamd_rcl_parse_struct_string (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+gboolean rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err);
/**
* Parse an integer field of a structure
* @param err error pointer
* @return TRUE if a value has been successfully parsed
*/
-gboolean rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+gboolean rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err);
/**
* @param err error pointer
* @return TRUE if a value has been successfully parsed
*/
-gboolean rspamd_rcl_parse_struct_double (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+gboolean rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err);
/**
* Parse a time field of a structure
* @param err error pointer
* @return TRUE if a value has been successfully parsed
*/
-gboolean rspamd_rcl_parse_struct_time (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+gboolean rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err);
/**
* Parse a string list field of a structure presented by a GList* object
* @param err error pointer
* @return TRUE if a value has been successfully parsed
*/
-gboolean rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+gboolean rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err);
/**
* Parse a boolean field of a structure
* @param err error pointer
* @return TRUE if a value has been successfully parsed
*/
-gboolean rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg, const ucl_object_t *obj,
- gpointer ud, struct rspamd_rcl_section *section, GError **err);
+gboolean rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
+ const ucl_object_t *obj,
+ gpointer ud,
+ struct rspamd_rcl_section *section,
+ GError **err);
/**
* Utility functions
* @param target opaque target structure
* @param offset offset inside a structure
*/
-void rspamd_rcl_register_worker_option (struct rspamd_config *cfg, gint type, const gchar *name,
- rspamd_rcl_handler_t handler, gpointer target, gsize offset, gint flags);
+void rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
+ gint type,
+ const gchar *name,
+ rspamd_rcl_handler_t handler,
+ gpointer target,
+ gsize offset,
+ gint flags);
/**
* Regiester a default parser for a worker
* @param ud userdata for handler function
*/
void rspamd_rcl_register_worker_parser (struct rspamd_config *cfg, gint type,
- gboolean (*func)(ucl_object_t *, gpointer), gpointer ud);
+ gboolean (*func)(ucl_object_t *, gpointer), gpointer ud);
#endif /* CFG_RCL_H_ */
#include "config.h"
#include "cfg_file.h"
-#include "main.h"
-#include "filter.h"
#include "classifiers/classifiers.h"
-#include "lua/lua_common.h"
+#include "dynamic_cfg.h"
+#include "filter.h"
#include "kvstorage_config.h"
+#include "lua/lua_common.h"
+#include "main.h"
#include "map.h"
-#include "dynamic_cfg.h"
#define DEFAULT_SCORE 10.0
struct rspamd_config *cfg;
GString *buf;
};
-static gchar* rspamd_ucl_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data);
-static void rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data);
+static gchar * rspamd_ucl_read_cb (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data);
+static void rspamd_ucl_fin_cb (rspamd_mempool_t * pool,
+ struct map_cb_data *data);
static gboolean
parse_host_port_priority_strv (rspamd_mempool_t *pool, gchar **tokens,
- gchar **addr, guint16 *port, guint *priority, guint default_port)
+ gchar **addr, guint16 *port, guint *priority, guint default_port)
{
- gchar *err_str, portbuf[8];
- const gchar *cur_tok, *cur_port;
- struct addrinfo hints, *res;
- guint port_parsed, priority_parsed, saved_errno = errno;
- gint r;
+ gchar *err_str, portbuf[8];
+ const gchar *cur_tok, *cur_port;
+ struct addrinfo hints, *res;
+ guint port_parsed, priority_parsed, saved_errno = errno;
+ gint r;
union {
struct sockaddr_in v4;
struct sockaddr_in6 v6;
errno = 0;
port_parsed = strtoul (tokens[1], &err_str, 10);
if (*err_str != '\0' || errno != 0) {
- msg_warn ("cannot parse port: %s, at symbol %c, error: %s", tokens[1], *err_str, strerror (errno));
+ msg_warn ("cannot parse port: %s, at symbol %c, error: %s",
+ tokens[1],
+ *err_str,
+ strerror (errno));
hints.ai_flags ^= AI_NUMERICSERV;
}
else if (port_parsed > G_MAXUINT16) {
errno = ERANGE;
- msg_warn ("cannot parse port: %s, error: %s", tokens[1], *err_str, strerror (errno));
+ msg_warn ("cannot parse port: %s, error: %s",
+ tokens[1],
+ *err_str,
+ strerror (errno));
hints.ai_flags ^= AI_NUMERICSERV;
}
else {
errno = 0;
priority_parsed = strtoul (cur_tok, &err_str, 10);
if (*err_str != '\0' || errno != 0) {
- msg_warn ("cannot parse priority: %s, at symbol %c, error: %s", tokens[1], *err_str, strerror (errno));
+ msg_warn (
+ "cannot parse priority: %s, at symbol %c, error: %s",
+ tokens[1],
+ *err_str,
+ strerror (errno));
}
else {
*priority = priority_parsed;
}
if ((r = getaddrinfo (cur_tok, cur_port, &hints, &res)) == 0) {
- memcpy (&addr_holder, res->ai_addr, MIN (sizeof (addr_holder), res->ai_addrlen));
+ memcpy (&addr_holder, res->ai_addr,
+ MIN (sizeof (addr_holder), res->ai_addrlen));
if (res->ai_family == AF_INET) {
if (pool != NULL) {
*addr = rspamd_mempool_alloc (pool, INET_ADDRSTRLEN + 1);
}
- inet_ntop (res->ai_family, &addr_holder.v4.sin_addr, *addr, INET_ADDRSTRLEN + 1);
+ inet_ntop (res->ai_family,
+ &addr_holder.v4.sin_addr,
+ *addr,
+ INET_ADDRSTRLEN + 1);
}
else {
if (pool != NULL) {
*addr = rspamd_mempool_alloc (pool, INET6_ADDRSTRLEN + 1);
}
- inet_ntop (res->ai_family, &addr_holder.v6.sin6_addr, *addr, INET6_ADDRSTRLEN + 1);
+ inet_ntop (res->ai_family,
+ &addr_holder.v6.sin6_addr,
+ *addr,
+ INET6_ADDRSTRLEN + 1);
}
freeaddrinfo (res);
}
else {
- msg_err ("address resolution for %s failed: %s", tokens[0], gai_strerror (r));
+ msg_err ("address resolution for %s failed: %s",
+ tokens[0],
+ gai_strerror (r));
goto err;
}
}
gboolean
-rspamd_parse_host_port_priority (rspamd_mempool_t *pool, const gchar *str, gchar **addr, guint16 *port, guint *priority)
+rspamd_parse_host_port_priority (rspamd_mempool_t *pool,
+ const gchar *str,
+ gchar **addr,
+ guint16 *port,
+ guint *priority)
{
- gchar **tokens;
- gboolean ret;
+ gchar **tokens;
+ gboolean ret;
tokens = g_strsplit_set (str, ":", 0);
if (!tokens || !tokens[0]) {
}
gboolean
-rspamd_parse_host_port (rspamd_mempool_t *pool, const gchar *str, gchar **addr, guint16 *port)
+rspamd_parse_host_port (rspamd_mempool_t *pool,
+ const gchar *str,
+ gchar **addr,
+ guint16 *port)
{
return rspamd_parse_host_port_priority (pool, str, addr, port, NULL);
}
gboolean
-rspamd_parse_host_priority (rspamd_mempool_t *pool, const gchar *str, gchar **addr, guint *priority)
+rspamd_parse_host_priority (rspamd_mempool_t *pool,
+ const gchar *str,
+ gchar **addr,
+ guint *priority)
{
return rspamd_parse_host_port_priority (pool, str, addr, NULL, priority);
}
gboolean
-rspamd_parse_bind_line (struct rspamd_config *cfg, struct rspamd_worker_conf *cf, const gchar *str)
+rspamd_parse_bind_line (struct rspamd_config *cfg,
+ struct rspamd_worker_conf *cf,
+ const gchar *str)
{
struct rspamd_worker_bind_conf *cnf;
gchar **tokens, *tmp, *err;
return FALSE;
}
- cnf = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_bind_conf));
+ cnf =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_worker_bind_conf));
cnf->bind_port = DEFAULT_BIND_PORT;
cnf->bind_host = rspamd_mempool_strdup (cfg->cfg_pool, str);
cnf->ai = AF_UNSPEC;
tokens[0] = "*v4";
cnf->ai = AF_INET;
if ((ret = parse_host_port_priority_strv (cfg->cfg_pool, tokens,
- &cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
+ &cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
LL_PREPEND (cf->bind_conf, cnf);
}
- cnf = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_bind_conf));
+ cnf =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_worker_bind_conf));
cnf->bind_port = DEFAULT_BIND_PORT;
cnf->bind_host = rspamd_mempool_strdup (cfg->cfg_pool, str);
cnf->ai = AF_INET6;
tokens[0] = "*v6";
if ((ret &= parse_host_port_priority_strv (cfg->cfg_pool, tokens,
- &cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
+ &cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
LL_PREPEND (cf->bind_conf, cnf);
}
tokens[0] = tmp;
cfg->metrics = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
cfg->c_modules = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
- cfg->composite_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
- cfg->classifiers_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ cfg->composite_symbols =
+ g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ cfg->classifiers_symbols = g_hash_table_new (rspamd_str_hash,
+ rspamd_str_equal);
cfg->cfg_params = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
cfg->metrics_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
void
rspamd_config_free (struct rspamd_config *cfg)
{
- GList *cur;
- struct rspamd_symbols_group *gr;
+ GList *cur;
+ struct rspamd_symbols_group *gr;
remove_all_maps (cfg);
ucl_obj_unref (cfg->rcl_obj);
rspamd_mempool_delete (cfg->cfg_pool);
}
-const ucl_object_t *
-rspamd_config_get_module_opt (struct rspamd_config *cfg, const gchar *module_name, const gchar *opt_name)
+const ucl_object_t *
+rspamd_config_get_module_opt (struct rspamd_config *cfg,
+ const gchar *module_name,
+ const gchar *opt_name)
{
const ucl_object_t *res = NULL, *sec;
guint64
rspamd_config_parse_limit (const gchar *limit, guint len)
{
- guint64 result = 0;
- const gchar *err_str;
+ guint64 result = 0;
+ const gchar *err_str;
if (!limit || *limit == '\0' || len == 0) {
return 0;
result *= 1073741824L;
}
else if (len > 0 && err_str - limit != (gint)len) {
- msg_warn ("invalid limit value '%s' at position '%s'", limit, err_str);
+ msg_warn ("invalid limit value '%s' at position '%s'",
+ limit,
+ err_str);
result = 0;
}
}
gchar
rspamd_config_parse_flag (const gchar *str)
{
- guint len;
- gchar c;
+ guint len;
+ gchar c;
if (!str || !*str) {
return -1;
}
gboolean
-rspamd_config_calculate_checksum (struct rspamd_config *cfg)
+rspamd_config_calculate_checksum (struct rspamd_config *cfg)
{
- gint fd;
- void *map;
- struct stat st;
+ gint fd;
+ void *map;
+ struct stat st;
/* Compute checksum for config file that should be used by xml dumper */
if ((fd = open (cfg->cfg_name, O_RDONLY)) == -1) {
- msg_err ("config file %s is no longer available, cannot calculate checksum");
+ msg_err (
+ "config file %s is no longer available, cannot calculate checksum");
return FALSE;
}
if (stat (cfg->cfg_name, &st) == -1) {
}
/* Now mmap this file to simplify reading process */
- if ((map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((map =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
msg_err ("cannot mmap %s: %s", cfg->cfg_name, strerror (errno));
close (fd);
return FALSE;
}
close (fd);
-
+
/* Get checksum for a file */
- cfg->checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5, map, st.st_size);
+ cfg->checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5,
+ map,
+ st.st_size);
munmap (map, st.st_size);
-
+
return TRUE;
}
-/*
+/*
* Perform post load actions
*/
void
rspamd_config_post_load (struct rspamd_config *cfg)
{
#ifdef HAVE_CLOCK_GETTIME
- struct timespec ts;
+ struct timespec ts;
#endif
- struct metric *def_metric;
+ struct metric *def_metric;
#ifdef HAVE_CLOCK_GETTIME
#ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
clock_getres (CLOCK_PROCESS_CPUTIME_ID, &ts);
# elif defined(HAVE_CLOCK_VIRTUAL)
- clock_getres (CLOCK_VIRTUAL, &ts);
+ clock_getres (CLOCK_VIRTUAL, &ts);
# else
- clock_getres (CLOCK_REALTIME, &ts);
+ clock_getres (CLOCK_REALTIME, &ts);
# endif
cfg->clock_res = (gint)log10 (1000000 / ts.tv_nsec);
if (cfg->clock_res > 3) {
cfg->clock_res = 3;
}
-#else
+#else
/* For gettimeofday */
cfg->clock_res = 1;
#endif
- if ((def_metric = g_hash_table_lookup (cfg->metrics, DEFAULT_METRIC)) == NULL) {
+ if ((def_metric =
+ g_hash_table_lookup (cfg->metrics, DEFAULT_METRIC)) == NULL) {
def_metric = rspamd_config_new_metric (cfg, NULL);
def_metric->name = DEFAULT_METRIC;
def_metric->actions[METRIC_ACTION_REJECT].score = DEFAULT_SCORE;
void
parse_err (const gchar *fmt, ...)
{
- va_list aq;
- gchar logbuf[BUFSIZ], readbuf[32];
- gint r;
+ va_list aq;
+ gchar logbuf[BUFSIZ], readbuf[32];
+ gint r;
va_start (aq, fmt);
rspamd_strlcpy (readbuf, yytext, sizeof (readbuf));
- r = snprintf (logbuf, sizeof (logbuf), "config file parse error! line: %d, text: %s, reason: ", yylineno, readbuf);
+ r = snprintf (logbuf,
+ sizeof (logbuf),
+ "config file parse error! line: %d, text: %s, reason: ",
+ yylineno,
+ readbuf);
r += vsnprintf (logbuf + r, sizeof (logbuf) - r, fmt, aq);
va_end (aq);
void
parse_warn (const gchar *fmt, ...)
{
- va_list aq;
- gchar logbuf[BUFSIZ], readbuf[32];
- gint r;
+ va_list aq;
+ gchar logbuf[BUFSIZ], readbuf[32];
+ gint r;
va_start (aq, fmt);
rspamd_strlcpy (readbuf, yytext, sizeof (readbuf));
- r = snprintf (logbuf, sizeof (logbuf), "config file parse warning! line: %d, text: %s, reason: ", yylineno, readbuf);
+ r = snprintf (logbuf,
+ sizeof (logbuf),
+ "config file parse warning! line: %d, text: %s, reason: ",
+ yylineno,
+ readbuf);
r += vsnprintf (logbuf + r, sizeof (logbuf) - r, fmt, aq);
va_end (aq);
void
rspamd_config_unescape_quotes (gchar *line)
{
- gchar *c = line, *t;
+ gchar *c = line, *t;
while (*c) {
if (*c == '\\' && *(c + 1) == '"') {
}
}
-GList *
+GList *
rspamd_config_parse_comma_list (rspamd_mempool_t * pool, const gchar *line)
{
- GList *res = NULL;
- const gchar *c, *p;
- gchar *str;
+ GList *res = NULL;
+ const gchar *c, *p;
+ gchar *str;
c = line;
p = c;
rspamd_strlcpy (str, c, p - c + 1);
res = g_list_prepend (res, str);
/* Skip spaces */
- while (g_ascii_isspace (*(++p)));
+ while (g_ascii_isspace (*(++p))) ;
c = p;
continue;
}
p++;
}
if (res != NULL) {
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_list_free, res);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_list_free,
+ res);
}
return res;
}
-struct rspamd_classifier_config *
-rspamd_config_new_classifier (struct rspamd_config *cfg, struct rspamd_classifier_config *c)
+struct rspamd_classifier_config *
+rspamd_config_new_classifier (struct rspamd_config *cfg,
+ struct rspamd_classifier_config *c)
{
if (c == NULL) {
- c = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_classifier_config));
+ c =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_classifier_config));
}
if (c->opts == NULL) {
c->opts = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->opts);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ c->opts);
}
if (c->labels == NULL) {
- c->labels = g_hash_table_new_full (rspamd_str_hash, rspamd_str_equal, NULL, (GDestroyNotify)g_list_free);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->labels);
+ c->labels = g_hash_table_new_full (rspamd_str_hash,
+ rspamd_str_equal,
+ NULL,
+ (GDestroyNotify)g_list_free);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ c->labels);
}
return c;
}
-struct rspamd_statfile_config*
-rspamd_config_new_statfile (struct rspamd_config *cfg, struct rspamd_statfile_config *c)
+struct rspamd_statfile_config *
+rspamd_config_new_statfile (struct rspamd_config *cfg,
+ struct rspamd_statfile_config *c)
{
if (c == NULL) {
- c = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_statfile_config));
+ c =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_statfile_config));
}
return c;
c->grow_factor = 1.0;
c->symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
c->descriptions = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
- for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
+ for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
c->actions[i].score = -1.0;
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->symbols);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->descriptions);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ c->symbols);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ c->descriptions);
}
return c;
}
struct rspamd_worker_conf *
-rspamd_config_new_worker (struct rspamd_config *cfg, struct rspamd_worker_conf *c)
+rspamd_config_new_worker (struct rspamd_config *cfg,
+ struct rspamd_worker_conf *c)
{
if (c == NULL) {
- c = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_conf));
+ c =
+ rspamd_mempool_alloc0 (cfg->cfg_pool,
+ sizeof (struct rspamd_worker_conf));
c->params = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
c->active_workers = g_queue_new ();
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_hash_table_destroy, c->params);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_queue_free, c->active_workers);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_hash_table_destroy,
+ c->params);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_queue_free,
+ c->active_workers);
#ifdef HAVE_SC_NPROCESSORS_ONLN
c->count = sysconf (_SC_NPROCESSORS_ONLN);
#else
c->rlimit_nofile = DEFAULT_RLIMIT_NOFILE;
c->rlimit_maxcore = DEFAULT_RLIMIT_MAXCORE;
}
-
+
return c;
}
static bool
-rspamd_include_map_handler (const guchar *data, gsize len, void* ud)
+rspamd_include_map_handler (const guchar *data, gsize len, void * ud)
{
struct rspamd_config *cfg = (struct rspamd_config *)ud;
struct rspamd_ucl_map_cbdata *cbdata, **pcbdata;
cbdata->cfg = cfg;
*pcbdata = cbdata;
- return add_map (cfg, map_line, "ucl include", rspamd_ucl_read_cb, rspamd_ucl_fin_cb, (void **)pcbdata);
+ return add_map (cfg,
+ map_line,
+ "ucl include",
+ rspamd_ucl_read_cb,
+ rspamd_ucl_fin_cb,
+ (void **)pcbdata);
}
/*
static void
rspamd_ucl_add_conf_variables (struct ucl_parser *parser)
{
- ucl_parser_register_variable (parser, RSPAMD_CONFDIR_MACRO, RSPAMD_CONFDIR);
- ucl_parser_register_variable (parser, RSPAMD_RUNDIR_MACRO, RSPAMD_RUNDIR);
- ucl_parser_register_variable (parser, RSPAMD_DBDIR_MACRO, RSPAMD_DBDIR);
- ucl_parser_register_variable (parser, RSPAMD_LOGDIR_MACRO, RSPAMD_LOGDIR);
- ucl_parser_register_variable (parser, RSPAMD_PLUGINSDIR_MACRO, RSPAMD_PLUGINSDIR);
- ucl_parser_register_variable (parser, RSPAMD_WWWDIR_MACRO, RSPAMD_WWWDIR);
- ucl_parser_register_variable (parser, RSPAMD_PREFIX_MACRO, RSPAMD_PREFIX);
+ ucl_parser_register_variable (parser,
+ RSPAMD_CONFDIR_MACRO,
+ RSPAMD_CONFDIR);
+ ucl_parser_register_variable (parser, RSPAMD_RUNDIR_MACRO,
+ RSPAMD_RUNDIR);
+ ucl_parser_register_variable (parser, RSPAMD_DBDIR_MACRO,
+ RSPAMD_DBDIR);
+ ucl_parser_register_variable (parser, RSPAMD_LOGDIR_MACRO,
+ RSPAMD_LOGDIR);
+ ucl_parser_register_variable (parser,
+ RSPAMD_PLUGINSDIR_MACRO,
+ RSPAMD_PLUGINSDIR);
+ ucl_parser_register_variable (parser, RSPAMD_WWWDIR_MACRO,
+ RSPAMD_WWWDIR);
+ ucl_parser_register_variable (parser, RSPAMD_PREFIX_MACRO,
+ RSPAMD_PREFIX);
ucl_parser_register_variable (parser, RSPAMD_VERSION_MACRO, RVERSION);
}
static void
-rspamd_ucl_add_conf_macros (struct ucl_parser *parser, struct rspamd_config *cfg)
+rspamd_ucl_add_conf_macros (struct ucl_parser *parser,
+ struct rspamd_config *cfg)
{
- ucl_parser_register_macro (parser, "include_map", rspamd_include_map_handler, cfg);
+ ucl_parser_register_macro (parser,
+ "include_map",
+ rspamd_include_map_handler,
+ cfg);
}
gboolean
rspamd_config_read (struct rspamd_config *cfg, const gchar *filename,
- const gchar *convert_to, rspamd_rcl_section_fin_t logger_fin,
- gpointer logger_ud)
+ const gchar *convert_to, rspamd_rcl_section_fin_t logger_fin,
+ gpointer logger_ud)
{
- struct stat st;
- gint fd;
- gchar *data;
- GError *err = NULL;
- struct rspamd_rcl_section *top, *logger;
+ struct stat st;
+ gint fd;
+ gchar *data;
+ GError *err = NULL;
+ struct rspamd_rcl_section *top, *logger;
gboolean res;
struct ucl_parser *parser;
if ((fd = open (filename, O_RDONLY)) == -1) {
msg_err ("cannot open %s: %s", filename, strerror (errno));
return FALSE;
-
+
}
/* Now mmap this file to simplify reading process */
- if ((data = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((data =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
msg_err ("cannot mmap %s: %s", filename, strerror (errno));
close (fd);
return FALSE;
top = rspamd_rcl_config_init ();
err = NULL;
- HASH_FIND_STR(top, "logging", logger);
+ HASH_FIND_STR (top, "logging", logger);
if (logger != NULL) {
logger->fin = logger_fin;
logger->fin_ud = logger_ud;
static void
symbols_classifiers_callback (gpointer key, gpointer value, gpointer ud)
{
- struct rspamd_config *cfg = ud;
+ struct rspamd_config *cfg = ud;
register_virtual_symbol (&cfg->cache, key, 1.0);
}
void
rspamd_config_insert_classify_symbols (struct rspamd_config *cfg)
{
- g_hash_table_foreach (cfg->classifiers_symbols, symbols_classifiers_callback, cfg);
+ g_hash_table_foreach (cfg->classifiers_symbols,
+ symbols_classifiers_callback,
+ cfg);
}
-struct rspamd_classifier_config*
+struct rspamd_classifier_config *
rspamd_config_find_classifier (struct rspamd_config *cfg, const gchar *name)
{
- GList *cur;
- struct rspamd_classifier_config *cf;
+ GList *cur;
+ struct rspamd_classifier_config *cf;
if (name == NULL) {
return NULL;
gboolean
rspamd_config_check_statfiles (struct rspamd_classifier_config *cf)
{
- struct rspamd_statfile_config *st;
- gboolean has_other = FALSE, res = FALSE, cur_class;
- GList *cur;
+ struct rspamd_statfile_config *st;
+ gboolean has_other = FALSE, res = FALSE, cur_class;
+ GList *cur;
/* First check classes directly */
cur = cf->statfiles;
return res;
}
-static gchar*
-rspamd_ucl_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+static gchar *
+rspamd_ucl_read_cb (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev;
static void
rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
{
- struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev = data->prev_data;
+ struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev =
+ data->prev_data;
ucl_object_t *obj;
struct ucl_parser *parser;
guint32 checksum;
if (data->map->checksum != checksum) {
/* New data available */
parser = ucl_parser_new (0);
- if (!ucl_parser_add_chunk (parser, cbdata->buf->str, cbdata->buf->len)) {
- msg_err ("cannot parse map %s: %s", data->map->uri, ucl_parser_get_error (parser));
+ if (!ucl_parser_add_chunk (parser, cbdata->buf->str,
+ cbdata->buf->len)) {
+ msg_err ("cannot parse map %s: %s",
+ data->map->uri,
+ ucl_parser_get_error (parser));
ucl_parser_free (parser);
}
else {
}
}
else {
- msg_info ("do not reload map %s, checksum is the same: %d", data->map->uri, checksum);
+ msg_info ("do not reload map %s, checksum is the same: %d",
+ data->map->uri,
+ checksum);
}
}
gboolean
rspamd_config_parse_ip_list (const gchar *ip_list, radix_tree_t **tree)
{
- gchar **strvec, **cur;
- struct in_addr ina;
- guint32 mask;
+ gchar **strvec, **cur;
+ struct in_addr ina;
+ guint32 mask;
strvec = g_strsplit_set (ip_list, ",", 0);
cur = strvec;
}
radix32tree_add (*tree, htonl (ina.s_addr), mask, 1);
}
- cur ++;
+ cur++;
}
return (*tree != NULL);
*/
#include "config.h"
-#include "main.h"
-#include "message.h"
#include "dkim.h"
#include "dns.h"
+#include "main.h"
+#include "message.h"
/* Parser of dkim params */
-typedef gboolean (*dkim_parse_param_f) (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-
-static gboolean rspamd_dkim_parse_signature (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_signalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_domain (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_canonalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_ignore (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_selector (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_version (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_timestamp (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_expiration (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
-static gboolean rspamd_dkim_parse_bodylength (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+typedef gboolean (*dkim_parse_param_f) (rspamd_dkim_context_t * ctx,
+ const gchar *param, gsize len, GError **err);
+
+static gboolean rspamd_dkim_parse_signature (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_signalg (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_domain (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_ignore (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_selector (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_version (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_timestamp (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_expiration (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
+static gboolean rspamd_dkim_parse_bodylength (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err);
static const dkim_parse_param_f parser_funcs[] = {
/* Parsers implementation */
static gboolean
-rspamd_dkim_parse_signature (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_signature (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
ctx->b = rspamd_mempool_alloc (ctx->pool, len + 1);
rspamd_strlcpy (ctx->b, param, len + 1);
}
static gboolean
-rspamd_dkim_parse_signalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_signalg (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
if (len == 8) {
if (memcmp (param, "rsa-sha1", len) == 0) {
}
}
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_A, "invalid dkim sign algorithm");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_INVALID_A,
+ "invalid dkim sign algorithm");
return FALSE;
}
static gboolean
-rspamd_dkim_parse_domain (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_domain (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
ctx->domain = rspamd_mempool_alloc (ctx->pool, len + 1);
rspamd_strlcpy (ctx->domain, param, len + 1);
}
static gboolean
-rspamd_dkim_parse_canonalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
- const gchar *p, *slash = NULL, *end = param + len;
- gsize sl = 0;
+ const gchar *p, *slash = NULL, *end = param + len;
+ gsize sl = 0;
p = param;
while (p != end) {
slash = p;
break;
}
- p ++;
- sl ++;
+ p++;
+ sl++;
}
if (slash == NULL) {
}
/* Check body */
len -= sl + 1;
- slash ++;
+ slash++;
if (len == 6 && memcmp (slash, "simple", len) == 0) {
ctx->body_canon_type = DKIM_CANON_SIMPLE;
return TRUE;
}
err:
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_A, "invalid dkim canonization algorithm");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_INVALID_A,
+ "invalid dkim canonization algorithm");
return FALSE;
}
static gboolean
-rspamd_dkim_parse_ignore (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_ignore (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
/* Just ignore unused params */
return TRUE;
}
static gboolean
-rspamd_dkim_parse_selector (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_selector (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
ctx->selector = rspamd_mempool_alloc (ctx->pool, len + 1);
rspamd_strlcpy (ctx->selector, param, len + 1);
return TRUE;
}
-static struct rspamd_dkim_header*
+static struct rspamd_dkim_header *
rspamd_dkim_find_header (GPtrArray *arr, const gchar *name, gsize len)
{
- guint i;
- struct rspamd_dkim_header *h;
+ guint i;
+ struct rspamd_dkim_header *h;
- for (i = 0; i < arr->len; i ++) {
+ for (i = 0; i < arr->len; i++) {
h = g_ptr_array_index (arr, i);
if (g_ascii_strncasecmp (h->name, name, len) == 0) {
return h;
static void
rspamd_dkim_hlist_free (void *ud)
{
- GPtrArray *a = ud;
+ GPtrArray *a = ud;
g_ptr_array_free (a, TRUE);
}
static gboolean
-rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
- const gchar *c, *p, *end = param + len;
- gchar *h;
- gboolean from_found = FALSE;
- guint count = 0;
- struct rspamd_dkim_header *new;
+ const gchar *c, *p, *end = param + len;
+ gchar *h;
+ gboolean from_found = FALSE;
+ guint count = 0;
+ struct rspamd_dkim_header *new;
p = param;
while (p <= end) {
if ((*p == ':' || p == end)) {
- count ++;
+ count++;
}
- p ++;
+ p++;
}
if (count > 0) {
p = param;
while (p <= end) {
if ((*p == ':' || p == end) && p - c > 0) {
- if ((new = rspamd_dkim_find_header (ctx->hlist, c, p - c)) != NULL) {
- new->count ++;
+ if ((new =
+ rspamd_dkim_find_header (ctx->hlist, c, p - c)) != NULL) {
+ new->count++;
}
else {
/* Insert new header to the list */
- new = rspamd_mempool_alloc (ctx->pool, sizeof (struct rspamd_dkim_header));
+ new =
+ rspamd_mempool_alloc (ctx->pool,
+ sizeof (struct rspamd_dkim_header));
h = rspamd_mempool_alloc (ctx->pool, p - c + 1);
rspamd_strlcpy (h, c, p - c + 1);
g_strstrip (h);
g_ptr_array_add (ctx->hlist, new);
}
c = p + 1;
- p ++;
+ p++;
}
else {
- p ++;
+ p++;
}
}
if (!ctx->hlist) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_H, "invalid dkim header list");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_INVALID_H,
+ "invalid dkim header list");
return FALSE;
}
else {
if (!from_found) {
g_ptr_array_free (ctx->hlist, TRUE);
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_H, "invalid dkim header list, from header is missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_INVALID_H,
+ "invalid dkim header list, from header is missing");
return FALSE;
}
/* Reverse list */
- rspamd_mempool_add_destructor (ctx->pool, (rspamd_mempool_destruct_t)rspamd_dkim_hlist_free, ctx->hlist);
+ rspamd_mempool_add_destructor (ctx->pool,
+ (rspamd_mempool_destruct_t)rspamd_dkim_hlist_free,
+ ctx->hlist);
}
return TRUE;
}
static gboolean
-rspamd_dkim_parse_version (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_version (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
if (len != 1 || *param != '1') {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_VERSION, "invalid dkim version");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_VERSION,
+ "invalid dkim version");
return FALSE;
}
}
static gboolean
-rspamd_dkim_parse_timestamp (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_timestamp (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
- gulong val;
+ gulong val;
if (!rspamd_strtoul (param, len, &val)) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim timestamp");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "invalid dkim timestamp");
return FALSE;
}
ctx->timestamp = val;
}
static gboolean
-rspamd_dkim_parse_expiration (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_expiration (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
- gulong val;
+ gulong val;
if (!rspamd_strtoul (param, len, &val)) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim expiration");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "invalid dkim expiration");
return FALSE;
}
ctx->expiration = val;
}
static gboolean
-rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
ctx->bh = rspamd_mempool_alloc (ctx->pool, len + 1);
rspamd_strlcpy (ctx->bh, param, len + 1);
}
static gboolean
-rspamd_dkim_parse_bodylength (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
+rspamd_dkim_parse_bodylength (rspamd_dkim_context_t * ctx,
+ const gchar *param,
+ gsize len,
+ GError **err)
{
- gulong val;
+ gulong val;
if (!rspamd_strtoul (param, len, &val)) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_L, "invalid dkim body length");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_INVALID_L,
+ "invalid dkim body length");
return FALSE;
}
ctx->len = val;
* @param err pointer to error object
* @return new context or NULL
*/
-rspamd_dkim_context_t*
-rspamd_create_dkim_context (const gchar *sig, rspamd_mempool_t *pool, guint time_jitter, GError **err)
+rspamd_dkim_context_t *
+rspamd_create_dkim_context (const gchar *sig,
+ rspamd_mempool_t *pool,
+ guint time_jitter,
+ GError **err)
{
- const gchar *p, *c, *tag = NULL, *end;
- gsize taglen;
- gint param = DKIM_PARAM_UNKNOWN;
- time_t now;
- rspamd_dkim_context_t *new;
+ const gchar *p, *c, *tag = NULL, *end;
+ gsize taglen;
+ gint param = DKIM_PARAM_UNKNOWN;
+ time_t now;
+ rspamd_dkim_context_t *new;
enum {
DKIM_STATE_TAG = 0,
DKIM_STATE_AFTER_TAG,
DKIM_STATE_VALUE,
DKIM_STATE_SKIP_SPACES = 99,
DKIM_STATE_ERROR = 100
- } state, next_state;
+ } state, next_state;
new = rspamd_mempool_alloc0 (pool, sizeof (rspamd_dkim_context_t));
taglen = p - c;
while (*p && g_ascii_isspace (*p)) {
/* Skip spaces before '=' sign */
- p ++;
+ p++;
}
if (*p != '=') {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "invalid dkim param");
state = DKIM_STATE_ERROR;
}
else {
state = DKIM_STATE_SKIP_SPACES;
next_state = DKIM_STATE_AFTER_TAG;
param = DKIM_PARAM_UNKNOWN;
- p ++;
+ p++;
tag = c;
}
}
state = DKIM_STATE_SKIP_SPACES;
next_state = DKIM_STATE_AFTER_TAG;
param = DKIM_PARAM_UNKNOWN;
- p ++;
+ p++;
tag = c;
}
else {
- taglen ++;
- p ++;
+ taglen++;
+ p++;
}
break;
case DKIM_STATE_AFTER_TAG:
/* We got tag at tag and len at taglen */
switch (taglen) {
case 0:
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "zero length dkim param");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "zero length dkim param");
state = DKIM_STATE_ERROR;
break;
case 1:
param = DKIM_PARAM_COPIEDHDRS;
break;
default:
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param: %c", *tag);
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "invalid dkim param: %c",
+ *tag);
state = DKIM_STATE_ERROR;
break;
}
param = DKIM_PARAM_BODYHASH;
}
else {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param: %c%c", tag[0], tag[1]);
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "invalid dkim param: %c%c",
+ tag[0],
+ tag[1]);
state = DKIM_STATE_ERROR;
}
break;
default:
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param length: %zd", taglen);
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_UNKNOWN,
+ "invalid dkim param length: %zd",
+ taglen);
state = DKIM_STATE_ERROR;
break;
}
break;
case DKIM_STATE_VALUE:
if (*p == ';') {
- if (param == DKIM_PARAM_UNKNOWN || !parser_funcs[param](new, c, p - c, err)) {
+ if (param == DKIM_PARAM_UNKNOWN ||
+ !parser_funcs[param](new, c, p - c, err)) {
state = DKIM_STATE_ERROR;
}
else {
state = DKIM_STATE_SKIP_SPACES;
next_state = DKIM_STATE_TAG;
- p ++;
+ p++;
taglen = 0;
}
}
else if (p == end) {
- if (param == DKIM_PARAM_UNKNOWN || !parser_funcs[param](new, c, p - c + 1, err)) {
+ if (param == DKIM_PARAM_UNKNOWN ||
+ !parser_funcs[param](new, c, p - c + 1, err)) {
state = DKIM_STATE_ERROR;
}
else {
/* Finish processing */
- p ++;
+ p++;
}
}
else {
- p ++;
+ p++;
}
break;
case DKIM_STATE_SKIP_SPACES:
if (g_ascii_isspace (*p)) {
- p ++;
+ p++;
}
else {
c = p;
/* Now check validity of signature */
if (new->b == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_B, "b parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_B,
+ "b parameter missing");
return NULL;
}
if (new->bh == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_BH, "bh parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_BH,
+ "bh parameter missing");
return NULL;
}
if (new->domain == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_D, "domain parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_D,
+ "domain parameter missing");
return NULL;
}
if (new->selector == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_S, "selector parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_S,
+ "selector parameter missing");
return NULL;
}
if (new->ver == 0) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_V, "v parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_V,
+ "v parameter missing");
return NULL;
}
if (new->hlist == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_H, "h parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_H,
+ "h parameter missing");
return NULL;
}
if (new->sig_alg == DKIM_SIGN_UNKNOWN) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_S, "s parameter missing");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EMPTY_S,
+ "s parameter missing");
return NULL;
}
if (new->sig_alg == DKIM_SIGN_RSASHA1) {
/* Check bh length */
if (new->bhlen != (guint)g_checksum_type_get_length (G_CHECKSUM_SHA1)) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_BADSIG, "signature has incorrect length: %ud", new->bhlen);
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_BADSIG,
+ "signature has incorrect length: %ud",
+ new->bhlen);
return NULL;
}
}
else if (new->sig_alg == DKIM_SIGN_RSASHA256) {
- if (new->bhlen != (guint)g_checksum_type_get_length (G_CHECKSUM_SHA256)) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_BADSIG, "signature has incorrect length: %ud", new->bhlen);
+ if (new->bhlen !=
+ (guint)g_checksum_type_get_length (G_CHECKSUM_SHA256)) {
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_BADSIG,
+ "signature has incorrect length: %ud",
+ new->bhlen);
return NULL;
}
}
/* Check expiration */
now = time (NULL);
- if (new->timestamp && now < new->timestamp && new->timestamp - now > (gint)time_jitter) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_FUTURE, "signature was made in future, ignoring");
+ if (new->timestamp && now < new->timestamp && new->timestamp - now >
+ (gint)time_jitter) {
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_FUTURE,
+ "signature was made in future, ignoring");
return NULL;
}
if (new->expiration && new->expiration < now) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EXPIRED, "signature has expired");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_EXPIRED,
+ "signature has expired");
return NULL;
}
/* Now create dns key to request further */
- taglen = strlen (new->domain) + strlen (new->selector) + sizeof (DKIM_DNSKEYNAME) + 2;
+ taglen = strlen (new->domain) + strlen (new->selector) +
+ sizeof (DKIM_DNSKEYNAME) + 2;
new->dns_key = rspamd_mempool_alloc (new->pool, taglen);
- rspamd_snprintf (new->dns_key, taglen, "%s.%s.%s", new->selector, DKIM_DNSKEYNAME, new->domain);
+ rspamd_snprintf (new->dns_key,
+ taglen,
+ "%s.%s.%s",
+ new->selector,
+ DKIM_DNSKEYNAME,
+ new->domain);
/* Create checksums for further operations */
if (new->sig_alg == DKIM_SIGN_RSASHA1) {
new->headers_hash = g_checksum_new (G_CHECKSUM_SHA256);
}
else {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_BADSIG, "signature has unsupported signature algorithm");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_BADSIG,
+ "signature has unsupported signature algorithm");
return NULL;
}
- rspamd_mempool_add_destructor (new->pool, (rspamd_mempool_destruct_t)g_checksum_free, new->body_hash);
- rspamd_mempool_add_destructor (new->pool, (rspamd_mempool_destruct_t)g_checksum_free, new->headers_hash);
+ rspamd_mempool_add_destructor (new->pool,
+ (rspamd_mempool_destruct_t)g_checksum_free,
+ new->body_hash);
+ rspamd_mempool_add_destructor (new->pool,
+ (rspamd_mempool_destruct_t)g_checksum_free,
+ new->headers_hash);
return new;
}
gpointer ud;
};
-static rspamd_dkim_key_t*
+static rspamd_dkim_key_t *
rspamd_dkim_make_key (const gchar *keydata, guint keylen, GError **err)
{
- rspamd_dkim_key_t *key = NULL;
+ rspamd_dkim_key_t *key = NULL;
if (keylen < 3) {
msg_err ("DKIM key is too short to be valid");
#ifdef HAVE_OPENSSL
key->key_bio = BIO_new_mem_buf (key->keydata, key->decoded_len);
if (key->key_bio == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "cannot make ssl bio from key");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_KEYFAIL,
+ "cannot make ssl bio from key");
rspamd_dkim_key_free (key);
return NULL;
}
key->key_evp = d2i_PUBKEY_bio (key->key_bio, NULL);
if (key->key_evp == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "cannot extract pubkey from bio");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_KEYFAIL,
+ "cannot extract pubkey from bio");
rspamd_dkim_key_free (key);
return NULL;
}
key->key_rsa = EVP_PKEY_get1_RSA (key->key_evp);
if (key->key_rsa == NULL) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "cannot extract rsa key from evp key");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_KEYFAIL,
+ "cannot extract rsa key from evp key");
rspamd_dkim_key_free (key);
return NULL;
}
BIO_free (key->key_bio);
}
#endif
- g_slice_free1 (key->keylen, key->keydata);
+ g_slice_free1 (key->keylen, key->keydata);
g_slice_free1 (sizeof (rspamd_dkim_key_t), key);
}
-static rspamd_dkim_key_t*
+static rspamd_dkim_key_t *
rspamd_dkim_parse_key (const gchar *txt, gsize *keylen, GError **err)
{
- const gchar *c, *p, *end;
- gint state = 0;
- gsize len;
+ const gchar *c, *p, *end;
+ gint state = 0;
+ gsize len;
c = txt;
p = txt;
}
else {
/* Ignore everything */
- p ++;
+ p++;
}
break;
case 1:
return rspamd_dkim_make_key (c, len, err);
}
else {
- p ++;
+ p++;
}
break;
}
}
if (p - c == 0) {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYREVOKED, "key was revoked");
+ g_set_error (err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_KEYREVOKED,
+ "key was revoked");
}
else {
- g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "key was not found");
+ g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL,
+ "key was not found");
}
return NULL;
static void
rspamd_dkim_dns_cb (struct rdns_reply *reply, gpointer arg)
{
- struct rspamd_dkim_key_cbdata *cbdata = arg;
- rspamd_dkim_key_t *key = NULL;
- GError *err = NULL;
- struct rdns_reply_entry *elt;
- gsize keylen = 0;
+ struct rspamd_dkim_key_cbdata *cbdata = arg;
+ rspamd_dkim_key_t *key = NULL;
+ GError *err = NULL;
+ struct rdns_reply_entry *elt;
+ gsize keylen = 0;
if (reply->code != RDNS_RC_NOERROR) {
- g_set_error (&err, DKIM_ERROR, DKIM_SIGERROR_NOKEY, "dns request to %s failed: %s", cbdata->ctx->dns_key,
- rdns_strerror (reply->code));
+ g_set_error (&err,
+ DKIM_ERROR,
+ DKIM_SIGERROR_NOKEY,
+ "dns request to %s failed: %s",
+ cbdata->ctx->dns_key,
+ rdns_strerror (reply->code));
cbdata->handler (NULL, 0, cbdata->ctx, cbdata->ud, err);
}
else {
- LL_FOREACH (reply->entries, elt) {
+ LL_FOREACH (reply->entries, elt)
+ {
if (elt->type == RDNS_REQUEST_TXT) {
- key = rspamd_dkim_parse_key (elt->content.txt.data, &keylen, &err);
+ key = rspamd_dkim_parse_key (elt->content.txt.data,
+ &keylen,
+ &err);
if (key) {
key->ttl = elt->ttl;
break;
* @return
*/
gboolean
-rspamd_get_dkim_key (rspamd_dkim_context_t *ctx, struct rspamd_dns_resolver *resolver,
- struct rspamd_async_session *s, dkim_key_handler_f handler, gpointer ud)
+rspamd_get_dkim_key (rspamd_dkim_context_t *ctx,
+ struct rspamd_dns_resolver *resolver,
+ struct rspamd_async_session *s,
+ dkim_key_handler_f handler,
+ gpointer ud)
{
- struct rspamd_dkim_key_cbdata *cbdata;
+ struct rspamd_dkim_key_cbdata *cbdata;
- g_return_val_if_fail (ctx != NULL, FALSE);
+ g_return_val_if_fail (ctx != NULL, FALSE);
g_return_val_if_fail (ctx->dns_key != NULL, FALSE);
- cbdata = rspamd_mempool_alloc (ctx->pool, sizeof (struct rspamd_dkim_key_cbdata));
+ cbdata =
+ rspamd_mempool_alloc (ctx->pool,
+ sizeof (struct rspamd_dkim_key_cbdata));
cbdata->ctx = ctx;
cbdata->handler = handler;
cbdata->ud = ud;
- return make_dns_request (resolver, s, ctx->pool, rspamd_dkim_dns_cb, cbdata, RDNS_REQUEST_TXT, ctx->dns_key);
+ return make_dns_request (resolver,
+ s,
+ ctx->pool,
+ rspamd_dkim_dns_cb,
+ cbdata,
+ RDNS_REQUEST_TXT,
+ ctx->dns_key);
}
static gboolean
rspamd_dkim_relaxed_body_step (GChecksum *ck, const gchar **start, guint remain)
{
- const gchar *h;
- static gchar buf[BUFSIZ];
- gchar *t;
- guint len, inlen;
- gboolean got_sp, finished = FALSE;
+ const gchar *h;
+ static gchar buf[BUFSIZ];
+ gchar *t;
+ guint len, inlen;
+ gboolean got_sp, finished = FALSE;
if (remain > sizeof (buf)) {
len = sizeof (buf);
/* Ignore spaces at the end of line */
if (got_sp) {
got_sp = FALSE;
- t --;
+ t--;
}
/* Replace a single \n or \r with \r\n */
if (*h == '\n' && *(h - 1) != '\r') {
- *t ++ = '\r';
- inlen --;
+ *t++ = '\r';
+ inlen--;
}
else if (*h == '\r' && *(h + 1) != '\n') {
- *t ++ = *h ++;
- *t ++ = '\n';
+ *t++ = *h++;
+ *t++ = '\n';
if (inlen > 1) {
inlen -= 2;
}
/* It is safe as inlen = sizeof (buf) - 1 */
inlen = 0;
}
- len --;
+ len--;
continue;
}
}
else if (g_ascii_isspace (*h)) {
if (got_sp) {
/* Ignore multiply spaces */
- h ++;
- len --;
+ h++;
+ len--;
continue;
}
else {
*t++ = ' ';
- h ++;
- inlen --;
- len --;
+ h++;
+ inlen--;
+ len--;
got_sp = TRUE;
continue;
}
got_sp = FALSE;
}
*t++ = *h++;
- inlen --;
- len --;
+ inlen--;
+ len--;
}
*start = h;
if (!finished && *(t - 1) == ' ' && g_ascii_isspace (*h)) {
/* Avoid border problems */
- t --;
+ t--;
}
#if 0
msg_debug ("update signature with buffer: %*s", t - buf, buf);
static gboolean
rspamd_dkim_simple_body_step (GChecksum *ck, const gchar **start, guint remain)
{
- const gchar *h;
- static gchar buf[BUFSIZ];
- gchar *t;
- guint len, inlen;
- gboolean finished = FALSE;
+ const gchar *h;
+ static gchar buf[BUFSIZ];
+ gchar *t;
+ guint len, inlen;
+ gboolean finished = FALSE;
if (remain > sizeof (buf)) {
len = sizeof (buf);
if (*h == '\r' || *h == '\n') {
/* Replace a single \n or \r with \r\n */
if (*h == '\n' && *(h - 1) != '\r') {
- *t ++ = '\r';
- inlen --;
+ *t++ = '\r';
+ inlen--;
}
else if (*h == '\r' && *(h + 1) != '\n') {
- *t ++ = *h ++;
- *t ++ = '\n';
+ *t++ = *h++;
+ *t++ = '\n';
if (inlen > 1) {
inlen -= 2;
}
/* It is safe as inlen = sizeof (buf) - 1 */
inlen = 0;
}
- len --;
+ len--;
continue;
}
}
*t++ = *h++;
- inlen --;
- len --;
+ inlen--;
+ len--;
}
*start = h;
}
static gboolean
-rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx, const gchar *start, const gchar *end)
+rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx,
+ const gchar *start,
+ const gchar *end)
{
const gchar *p;
p -= 2;
}
else if (*p == '\n' && *(p - 1) == '\n') {
- p --;
+ p--;
}
else if (*p == '\r' && *(p - 1) == '\r') {
- p --;
+ p--;
}
else {
break;
else {
if (ctx->body_canon_type == DKIM_CANON_SIMPLE) {
/* Simple canonization */
- while (rspamd_dkim_simple_body_step (ctx->body_hash, &start, end - start));
+ while (rspamd_dkim_simple_body_step (ctx->body_hash, &start,
+ end - start)) ;
}
else {
- while (rspamd_dkim_relaxed_body_step (ctx->body_hash, &start, end - start));
+ while (rspamd_dkim_relaxed_body_step (ctx->body_hash, &start,
+ end - start)) ;
}
}
return TRUE;
static void
rspamd_dkim_hash_update (GChecksum *ck, const gchar *begin, gsize len)
{
- const gchar *p, *c, *end;
+ const gchar *p, *c, *end;
end = begin + len;
p = begin;
c = p;
while (p != end) {
if (*p == '\r') {
- g_checksum_update (ck, c, p - c);
+ g_checksum_update (ck, c, p - c);
g_checksum_update (ck, CRLF, sizeof (CRLF) - 1);
- p ++;
+ p++;
if (*p == '\n') {
- p ++;
+ p++;
}
c = p;
}
else if (*p == '\n') {
- g_checksum_update (ck, c, p - c);
+ g_checksum_update (ck, c, p - c);
g_checksum_update (ck, CRLF, sizeof (CRLF) - 1);
- p ++;
+ p++;
c = p;
}
else {
- p ++;
+ p++;
}
}
if (p != c) {
/* Update hash by signature value (ignoring b= tag) */
static void
-rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx, const gchar *begin, guint len)
+rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx,
+ const gchar *begin,
+ guint len)
{
- const gchar *p, *c, *end;
- gboolean tag, skip;
+ const gchar *p, *c, *end;
+ gboolean tag, skip;
end = begin + len;
p = begin;
while (p < end) {
if (tag && p[0] == 'b' && p[1] == '=') {
/* Add to signature */
- msg_debug ("initial update hash with signature part: %*s", p - c + 2, c);
+ msg_debug ("initial update hash with signature part: %*s",
+ p - c + 2,
+ c);
rspamd_dkim_hash_update (ctx->headers_hash, c, p - c + 2);
skip = TRUE;
}
else if (tag && *p == '=') {
tag = FALSE;
}
- p ++;
+ p++;
}
- p --;
+ p--;
/* Skip \r\n at the end */
while ((*p == '\r' || *p == '\n') && p >= c) {
- p --;
+ p--;
}
if (p - c + 1 > 0) {
}
static gboolean
-rspamd_dkim_canonize_header_relaxed (rspamd_dkim_context_t *ctx, const gchar *header, const gchar *header_name, gboolean is_sign)
+rspamd_dkim_canonize_header_relaxed (rspamd_dkim_context_t *ctx,
+ const gchar *header,
+ const gchar *header_name,
+ gboolean is_sign)
{
- const gchar *h;
- gchar *t, *buf;
- guint inlen;
- gboolean got_sp, allocated = FALSE;
+ const gchar *h;
+ gchar *t, *buf;
+ guint inlen;
+ gboolean got_sp, allocated = FALSE;
inlen = strlen (header) + strlen (header_name) + sizeof (":" CRLF);
if (inlen > BUFSIZ) {
t = buf;
h = header_name;
while (*h) {
- *t ++ = g_ascii_tolower (*h++);
+ *t++ = g_ascii_tolower (*h++);
}
*t++ = ':';
h = header;
/* Skip spaces at the beginning */
while (g_ascii_isspace (*h)) {
- h ++;
+ h++;
}
got_sp = FALSE;
while (*h) {
if (g_ascii_isspace (*h)) {
if (got_sp) {
- h ++;
+ h++;
continue;
}
else {
got_sp = TRUE;
- *t ++ = ' ';
- h ++;
+ *t++ = ' ';
+ h++;
continue;
}
}
else {
got_sp = FALSE;
}
- *t ++ = *h ++;
+ *t++ = *h++;
}
if (g_ascii_isspace (*(t - 1))) {
- t --;
+ t--;
}
*t++ = '\r';
*t++ = '\n';
};
static gboolean
-rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx, const gchar *headers,
- const gchar *header_name, guint count, gboolean is_sign)
+rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
+ const gchar *headers,
+ const gchar *header_name,
+ guint count,
+ gboolean is_sign)
{
- const gchar *p, *c;
- gint state = 0, hlen;
- gboolean found = FALSE;
- GArray *to_sign;
- struct rspamd_dkim_sign_chunk chunk, *elt;
- gint i;
+ const gchar *p, *c;
+ gint state = 0, hlen;
+ gboolean found = FALSE;
+ GArray *to_sign;
+ struct rspamd_dkim_sign_chunk chunk, *elt;
+ gint i;
/* This process is very similar to raw headers processing */
- to_sign = g_array_sized_new (FALSE, FALSE, sizeof (struct rspamd_dkim_sign_chunk), count);
+ to_sign =
+ g_array_sized_new (FALSE,
+ FALSE,
+ sizeof (struct rspamd_dkim_sign_chunk),
+ count);
p = headers;
c = p;
hlen = strlen (header_name);
state = 1;
}
}
- p ++;
+ p++;
break;
case 1:
/* Skip header state */
state = 0;
c = p + 1;
}
- p ++;
+ p++;
break;
case 2:
/* c contains the beginning of header */
state = 0;
found = TRUE;
}
- p ++;
+ p++;
break;
}
}
if (found) {
if (!is_sign) {
- for (i = to_sign->len - 1; i >= 0 && count > 0; i --, count --) {
- elt = &g_array_index (to_sign, struct rspamd_dkim_sign_chunk, i);
+ for (i = to_sign->len - 1; i >= 0 && count > 0; i--, count--) {
+ elt =
+ &g_array_index (to_sign, struct rspamd_dkim_sign_chunk, i);
if (!chunk.append_crlf) {
- msg_debug ("update signature with header: %*s", elt->len, elt->begin);
- rspamd_dkim_hash_update (ctx->headers_hash, elt->begin, elt->len);
+ msg_debug ("update signature with header: %*s",
+ elt->len,
+ elt->begin);
+ rspamd_dkim_hash_update (ctx->headers_hash,
+ elt->begin,
+ elt->len);
}
else {
- msg_debug ("update signature with header: %*s", elt->len + 1, elt->begin);
- rspamd_dkim_hash_update (ctx->headers_hash, elt->begin, elt->len + 1);
+ msg_debug ("update signature with header: %*s",
+ elt->len + 1,
+ elt->begin);
+ rspamd_dkim_hash_update (ctx->headers_hash,
+ elt->begin,
+ elt->len + 1);
}
}
}
}
static gboolean
-rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx, struct rspamd_task *task, const gchar *header_name,
- guint count, gboolean is_sig)
+rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
+ struct rspamd_task *task,
+ const gchar *header_name,
+ guint count,
+ gboolean is_sig)
{
- struct raw_header *rh, *rh_iter;
- guint rh_num = 0;
- GList *nh = NULL, *cur;
+ struct raw_header *rh, *rh_iter;
+ guint rh_num = 0;
+ GList *nh = NULL, *cur;
if (ctx->header_canon_type == DKIM_CANON_SIMPLE) {
- return rspamd_dkim_canonize_header_simple (ctx, task->raw_headers_str, header_name, count, is_sig);
+ return rspamd_dkim_canonize_header_simple (ctx,
+ task->raw_headers_str,
+ header_name,
+ count,
+ is_sig);
}
else {
rh = g_hash_table_lookup (task->raw_headers, header_name);
if (!is_sig) {
rh_iter = rh;
while (rh_iter) {
- rh_num ++;
+ rh_num++;
rh_iter = rh_iter->next;
}
rh_iter = rh;
while (rh_num) {
rh_iter = rh_iter->next;
- rh_num --;
+ rh_num--;
}
/* Now insert required headers */
while (rh_iter) {
cur = nh;
while (cur) {
rh = cur->data;
- if (! rspamd_dkim_canonize_header_relaxed (ctx, rh->value, header_name, is_sig)) {
+ if (!rspamd_dkim_canonize_header_relaxed (ctx, rh->value,
+ header_name, is_sig)) {
g_list_free (nh);
return FALSE;
}
}
else {
/* For signature check just use the first dkim header */
- rspamd_dkim_canonize_header_relaxed (ctx, rh->value, header_name, is_sig);
+ rspamd_dkim_canonize_header_relaxed (ctx,
+ rh->value,
+ header_name,
+ is_sig);
}
return TRUE;
}
* @return
*/
gint
-rspamd_dkim_check (rspamd_dkim_context_t *ctx, rspamd_dkim_key_t *key, struct rspamd_task *task)
+rspamd_dkim_check (rspamd_dkim_context_t *ctx,
+ rspamd_dkim_key_t *key,
+ struct rspamd_task *task)
{
- const gchar *p, *headers_end = NULL, *end, *body_end;
- gboolean got_cr = FALSE, got_crlf = FALSE, got_lf = FALSE;
- gchar *digest;
- gsize dlen;
- gint res = DKIM_CONTINUE;
- guint i;
- struct rspamd_dkim_header *dh;
+ const gchar *p, *headers_end = NULL, *end, *body_end;
+ gboolean got_cr = FALSE, got_crlf = FALSE, got_lf = FALSE;
+ gchar *digest;
+ gsize dlen;
+ gint res = DKIM_CONTINUE;
+ guint i;
+ struct rspamd_dkim_header *dh;
#ifdef HAVE_OPENSSL
- gint nid;
+ gint nid;
#endif
- g_return_val_if_fail (ctx != NULL, DKIM_ERROR);
- g_return_val_if_fail (key != NULL, DKIM_ERROR);
+ g_return_val_if_fail (ctx != NULL, DKIM_ERROR);
+ g_return_val_if_fail (key != NULL, DKIM_ERROR);
g_return_val_if_fail (task->msg != NULL, DKIM_ERROR);
/* First of all find place of body */
got_cr = FALSE;
got_crlf = FALSE;
}
- p ++;
+ p++;
}
/* Start canonization of body part */
return DKIM_RECORD_ERROR;
}
/* Now canonize headers */
- for (i = 0; i < ctx->hlist->len; i ++) {
+ for (i = 0; i < ctx->hlist->len; i++) {
dh = g_ptr_array_index (ctx->hlist, i);
rspamd_dkim_canonize_header (ctx, task, dh->name, dh->count, FALSE);
}
#define DKIM_H_
#include "config.h"
-#include "event.h"
#include "dns.h"
+#include "event.h"
#ifdef HAVE_OPENSSL
-#include <openssl/rsa.h>
#include <openssl/engine.h>
+#include <openssl/rsa.h>
#endif
/* Main types and definitions */
-#define DKIM_SIGNHEADER "DKIM-Signature"
- /* DKIM signature header */
+#define DKIM_SIGNHEADER "DKIM-Signature"
+/* DKIM signature header */
/* special DNS tokens */
-#define DKIM_DNSKEYNAME "_domainkey"
- /* reserved DNS sub-zone */
-#define DKIM_DNSPOLICYNAME "_adsp" /* reserved DNS sub-zone */
+#define DKIM_DNSKEYNAME "_domainkey"
+/* reserved DNS sub-zone */
+#define DKIM_DNSPOLICYNAME "_adsp" /* reserved DNS sub-zone */
/* Canonization methods */
-#define DKIM_CANON_UNKNOWN (-1) /* unknown method */
-#define DKIM_CANON_SIMPLE 0 /* as specified in DKIM spec */
-#define DKIM_CANON_RELAXED 1 /* as specified in DKIM spec */
+#define DKIM_CANON_UNKNOWN (-1) /* unknown method */
+#define DKIM_CANON_SIMPLE 0 /* as specified in DKIM spec */
+#define DKIM_CANON_RELAXED 1 /* as specified in DKIM spec */
-#define DKIM_CANON_DEFAULT DKIM_CANON_SIMPLE
+#define DKIM_CANON_DEFAULT DKIM_CANON_SIMPLE
/* Signature methods */
-#define DKIM_SIGN_UNKNOWN (-2) /* unknown method */
-#define DKIM_SIGN_DEFAULT (-1) /* use internal default */
-#define DKIM_SIGN_RSASHA1 0 /* an RSA-signed SHA1 digest */
-#define DKIM_SIGN_RSASHA256 1 /* an RSA-signed SHA256 digest */
+#define DKIM_SIGN_UNKNOWN (-2) /* unknown method */
+#define DKIM_SIGN_DEFAULT (-1) /* use internal default */
+#define DKIM_SIGN_RSASHA1 0 /* an RSA-signed SHA1 digest */
+#define DKIM_SIGN_RSASHA256 1 /* an RSA-signed SHA256 digest */
/* Params */
-#define DKIM_PARAM_UNKNOWN (-1) /* unknown */
-#define DKIM_PARAM_SIGNATURE 0 /* b */
-#define DKIM_PARAM_SIGNALG 1 /* a */
-#define DKIM_PARAM_DOMAIN 2 /* d */
-#define DKIM_PARAM_CANONALG 3 /* c */
-#define DKIM_PARAM_QUERYMETHOD 4 /* q */
-#define DKIM_PARAM_SELECTOR 5 /* s */
-#define DKIM_PARAM_HDRLIST 6 /* h */
-#define DKIM_PARAM_VERSION 7 /* v */
-#define DKIM_PARAM_IDENTITY 8 /* i */
-#define DKIM_PARAM_TIMESTAMP 9 /* t */
-#define DKIM_PARAM_EXPIRATION 10 /* x */
-#define DKIM_PARAM_COPIEDHDRS 11 /* z */
-#define DKIM_PARAM_BODYHASH 12 /* bh */
-#define DKIM_PARAM_BODYLENGTH 13 /* l */
+#define DKIM_PARAM_UNKNOWN (-1) /* unknown */
+#define DKIM_PARAM_SIGNATURE 0 /* b */
+#define DKIM_PARAM_SIGNALG 1 /* a */
+#define DKIM_PARAM_DOMAIN 2 /* d */
+#define DKIM_PARAM_CANONALG 3 /* c */
+#define DKIM_PARAM_QUERYMETHOD 4 /* q */
+#define DKIM_PARAM_SELECTOR 5 /* s */
+#define DKIM_PARAM_HDRLIST 6 /* h */
+#define DKIM_PARAM_VERSION 7 /* v */
+#define DKIM_PARAM_IDENTITY 8 /* i */
+#define DKIM_PARAM_TIMESTAMP 9 /* t */
+#define DKIM_PARAM_EXPIRATION 10 /* x */
+#define DKIM_PARAM_COPIEDHDRS 11 /* z */
+#define DKIM_PARAM_BODYHASH 12 /* bh */
+#define DKIM_PARAM_BODYLENGTH 13 /* l */
/* Errors (from OpenDKIM) */
-#define DKIM_SIGERROR_UNKNOWN (-1) /* unknown error */
-#define DKIM_SIGERROR_OK 0 /* no error */
-#define DKIM_SIGERROR_VERSION 1 /* unsupported version */
-#define DKIM_SIGERROR_DOMAIN 2 /* invalid domain (d=/i=) */
-#define DKIM_SIGERROR_EXPIRED 3 /* signature expired */
-#define DKIM_SIGERROR_FUTURE 4 /* signature in the future */
-#define DKIM_SIGERROR_TIMESTAMPS 5 /* x= < t= */
-#define DKIM_SIGERROR_UNUSED 6 /* OBSOLETE */
-#define DKIM_SIGERROR_INVALID_HC 7 /* c= invalid (header) */
-#define DKIM_SIGERROR_INVALID_BC 8 /* c= invalid (body) */
-#define DKIM_SIGERROR_MISSING_A 9 /* a= missing */
-#define DKIM_SIGERROR_INVALID_A 10 /* a= invalid */
-#define DKIM_SIGERROR_MISSING_H 11 /* h= missing */
-#define DKIM_SIGERROR_INVALID_L 12 /* l= invalid */
-#define DKIM_SIGERROR_INVALID_Q 13 /* q= invalid */
-#define DKIM_SIGERROR_INVALID_QO 14 /* q= option invalid */
-#define DKIM_SIGERROR_MISSING_D 15 /* d= missing */
-#define DKIM_SIGERROR_EMPTY_D 16 /* d= empty */
-#define DKIM_SIGERROR_MISSING_S 17 /* s= missing */
-#define DKIM_SIGERROR_EMPTY_S 18 /* s= empty */
-#define DKIM_SIGERROR_MISSING_B 19 /* b= missing */
-#define DKIM_SIGERROR_EMPTY_B 20 /* b= empty */
-#define DKIM_SIGERROR_CORRUPT_B 21 /* b= corrupt */
-#define DKIM_SIGERROR_NOKEY 22 /* no key found in DNS */
-#define DKIM_SIGERROR_DNSSYNTAX 23 /* DNS reply corrupt */
-#define DKIM_SIGERROR_KEYFAIL 24 /* DNS query failed */
-#define DKIM_SIGERROR_MISSING_BH 25 /* bh= missing */
-#define DKIM_SIGERROR_EMPTY_BH 26 /* bh= empty */
-#define DKIM_SIGERROR_CORRUPT_BH 27 /* bh= corrupt */
-#define DKIM_SIGERROR_BADSIG 28 /* signature mismatch */
-#define DKIM_SIGERROR_SUBDOMAIN 29 /* unauthorized subdomain */
-#define DKIM_SIGERROR_MULTIREPLY 30 /* multiple records returned */
-#define DKIM_SIGERROR_EMPTY_H 31 /* h= empty */
-#define DKIM_SIGERROR_INVALID_H 32 /* h= missing req'd entries */
-#define DKIM_SIGERROR_TOOLARGE_L 33 /* l= value exceeds body size */
-#define DKIM_SIGERROR_MBSFAILED 34 /* "must be signed" failure */
-#define DKIM_SIGERROR_KEYVERSION 35 /* unknown key version */
-#define DKIM_SIGERROR_KEYUNKNOWNHASH 36 /* unknown key hash */
-#define DKIM_SIGERROR_KEYHASHMISMATCH 37 /* sig-key hash mismatch */
-#define DKIM_SIGERROR_NOTEMAILKEY 38 /* not an e-mail key */
-#define DKIM_SIGERROR_UNUSED2 39 /* OBSOLETE */
-#define DKIM_SIGERROR_KEYTYPEMISSING 40 /* key type missing */
-#define DKIM_SIGERROR_KEYTYPEUNKNOWN 41 /* key type unknown */
-#define DKIM_SIGERROR_KEYREVOKED 42 /* key revoked */
-#define DKIM_SIGERROR_KEYDECODE 43 /* key couldn't be decoded */
-#define DKIM_SIGERROR_MISSING_V 44 /* v= tag missing */
-#define DKIM_SIGERROR_EMPTY_V 45 /* v= tag empty */
+#define DKIM_SIGERROR_UNKNOWN (-1) /* unknown error */
+#define DKIM_SIGERROR_OK 0 /* no error */
+#define DKIM_SIGERROR_VERSION 1 /* unsupported version */
+#define DKIM_SIGERROR_DOMAIN 2 /* invalid domain (d=/i=) */
+#define DKIM_SIGERROR_EXPIRED 3 /* signature expired */
+#define DKIM_SIGERROR_FUTURE 4 /* signature in the future */
+#define DKIM_SIGERROR_TIMESTAMPS 5 /* x= < t= */
+#define DKIM_SIGERROR_UNUSED 6 /* OBSOLETE */
+#define DKIM_SIGERROR_INVALID_HC 7 /* c= invalid (header) */
+#define DKIM_SIGERROR_INVALID_BC 8 /* c= invalid (body) */
+#define DKIM_SIGERROR_MISSING_A 9 /* a= missing */
+#define DKIM_SIGERROR_INVALID_A 10 /* a= invalid */
+#define DKIM_SIGERROR_MISSING_H 11 /* h= missing */
+#define DKIM_SIGERROR_INVALID_L 12 /* l= invalid */
+#define DKIM_SIGERROR_INVALID_Q 13 /* q= invalid */
+#define DKIM_SIGERROR_INVALID_QO 14 /* q= option invalid */
+#define DKIM_SIGERROR_MISSING_D 15 /* d= missing */
+#define DKIM_SIGERROR_EMPTY_D 16 /* d= empty */
+#define DKIM_SIGERROR_MISSING_S 17 /* s= missing */
+#define DKIM_SIGERROR_EMPTY_S 18 /* s= empty */
+#define DKIM_SIGERROR_MISSING_B 19 /* b= missing */
+#define DKIM_SIGERROR_EMPTY_B 20 /* b= empty */
+#define DKIM_SIGERROR_CORRUPT_B 21 /* b= corrupt */
+#define DKIM_SIGERROR_NOKEY 22 /* no key found in DNS */
+#define DKIM_SIGERROR_DNSSYNTAX 23 /* DNS reply corrupt */
+#define DKIM_SIGERROR_KEYFAIL 24 /* DNS query failed */
+#define DKIM_SIGERROR_MISSING_BH 25 /* bh= missing */
+#define DKIM_SIGERROR_EMPTY_BH 26 /* bh= empty */
+#define DKIM_SIGERROR_CORRUPT_BH 27 /* bh= corrupt */
+#define DKIM_SIGERROR_BADSIG 28 /* signature mismatch */
+#define DKIM_SIGERROR_SUBDOMAIN 29 /* unauthorized subdomain */
+#define DKIM_SIGERROR_MULTIREPLY 30 /* multiple records returned */
+#define DKIM_SIGERROR_EMPTY_H 31 /* h= empty */
+#define DKIM_SIGERROR_INVALID_H 32 /* h= missing req'd entries */
+#define DKIM_SIGERROR_TOOLARGE_L 33 /* l= value exceeds body size */
+#define DKIM_SIGERROR_MBSFAILED 34 /* "must be signed" failure */
+#define DKIM_SIGERROR_KEYVERSION 35 /* unknown key version */
+#define DKIM_SIGERROR_KEYUNKNOWNHASH 36 /* unknown key hash */
+#define DKIM_SIGERROR_KEYHASHMISMATCH 37 /* sig-key hash mismatch */
+#define DKIM_SIGERROR_NOTEMAILKEY 38 /* not an e-mail key */
+#define DKIM_SIGERROR_UNUSED2 39 /* OBSOLETE */
+#define DKIM_SIGERROR_KEYTYPEMISSING 40 /* key type missing */
+#define DKIM_SIGERROR_KEYTYPEUNKNOWN 41 /* key type unknown */
+#define DKIM_SIGERROR_KEYREVOKED 42 /* key revoked */
+#define DKIM_SIGERROR_KEYDECODE 43 /* key couldn't be decoded */
+#define DKIM_SIGERROR_MISSING_V 44 /* v= tag missing */
+#define DKIM_SIGERROR_EMPTY_V 45 /* v= tag empty */
/* Check results */
-#define DKIM_CONTINUE 0 /* continue */
-#define DKIM_REJECT 1 /* reject */
-#define DKIM_TRYAGAIN 2 /* try again later */
-#define DKIM_NOTFOUND 3 /* requested record not found */
-#define DKIM_RECORD_ERROR 4 /* error requesting record */
+#define DKIM_CONTINUE 0 /* continue */
+#define DKIM_REJECT 1 /* reject */
+#define DKIM_TRYAGAIN 2 /* try again later */
+#define DKIM_NOTFOUND 3 /* requested record not found */
+#define DKIM_RECORD_ERROR 4 /* error requesting record */
typedef struct rspamd_dkim_context_s {
rspamd_mempool_t *pool;
struct rspamd_task;
/* Err MUST be freed if it is not NULL, key is allocated by slice allocator */
-typedef void (*dkim_key_handler_f)(rspamd_dkim_key_t *key, gsize keylen, rspamd_dkim_context_t *ctx, gpointer ud, GError *err);
+typedef void (*dkim_key_handler_f)(rspamd_dkim_key_t *key, gsize keylen,
+ rspamd_dkim_context_t *ctx, gpointer ud, GError *err);
/**
* Create new dkim context from signature
* @param err pointer to error object
* @return new context or NULL
*/
-rspamd_dkim_context_t* rspamd_create_dkim_context (const gchar *sig, rspamd_mempool_t *pool, guint time_jitter, GError **err);
+rspamd_dkim_context_t * rspamd_create_dkim_context (const gchar *sig,
+ rspamd_mempool_t *pool,
+ guint time_jitter,
+ GError **err);
/**
* Make DNS request for specified context and obtain and parse key
* @param s async session to make request
* @return
*/
-gboolean rspamd_get_dkim_key (rspamd_dkim_context_t *ctx, struct rspamd_dns_resolver *resolver,
- struct rspamd_async_session *s, dkim_key_handler_f handler, gpointer ud);
+gboolean rspamd_get_dkim_key (rspamd_dkim_context_t *ctx,
+ struct rspamd_dns_resolver *resolver,
+ struct rspamd_async_session *s,
+ dkim_key_handler_f handler,
+ gpointer ud);
/**
* Check task for dkim context using dkim key
* @param task task to check
* @return
*/
-gint rspamd_dkim_check (rspamd_dkim_context_t *ctx, rspamd_dkim_key_t *key, struct rspamd_task *task);
+gint rspamd_dkim_check (rspamd_dkim_context_t *ctx,
+ rspamd_dkim_key_t *key,
+ struct rspamd_task *task);
/**
* Free DKIM key
#include "config.h"
#include "dns.h"
#include "main.h"
-#include "utlist.h"
-#include "uthash.h"
#include "rdns_event.h"
+#include "uthash.h"
+#include "utlist.h"
struct rspamd_dns_resolver {
struct rdns_resolver *r;
rspamd_dns_fin_cb (gpointer arg)
{
struct rdns_request *req = arg;
-
+
rdns_request_release (req);
}
remove_normal_event (reqdata->session, rspamd_dns_fin_cb, reqdata->req);
}
-gboolean
+gboolean
make_dns_request (struct rspamd_dns_resolver *resolver,
- struct rspamd_async_session *session, rspamd_mempool_t *pool, dns_callback_type cb,
- gpointer ud, enum rdns_request_type type, const char *name)
+ struct rspamd_async_session *session,
+ rspamd_mempool_t *pool,
+ dns_callback_type cb,
+ gpointer ud,
+ enum rdns_request_type type,
+ const char *name)
{
struct rdns_request *req;
struct rspamd_dns_request_ud *reqdata;
-
- reqdata = rspamd_mempool_alloc (pool, sizeof (struct rspamd_dns_request_ud));
+
+ reqdata =
+ rspamd_mempool_alloc (pool, sizeof (struct rspamd_dns_request_ud));
reqdata->session = session;
reqdata->cb = cb;
reqdata->ud = ud;
req = rdns_make_request_full (resolver->r, rspamd_dns_callback, reqdata,
- resolver->request_timeout, resolver->max_retransmits, 1, name, type);
+ resolver->request_timeout, resolver->max_retransmits, 1, name,
+ type);
if (req != NULL) {
- register_async_event (session, (event_finalizer_t)rspamd_dns_fin_cb, req,
- g_quark_from_static_string ("dns resolver"));
+ register_async_event (session,
+ (event_finalizer_t)rspamd_dns_fin_cb,
+ req,
+ g_quark_from_static_string ("dns resolver"));
reqdata->req = req;
}
else {
struct rspamd_dns_resolver *
-dns_resolver_init (rspamd_logger_t *logger, struct event_base *ev_base, struct rspamd_config *cfg)
+dns_resolver_init (rspamd_logger_t *logger,
+ struct event_base *ev_base,
+ struct rspamd_config *cfg)
{
- GList *cur;
- struct rspamd_dns_resolver *new;
- gchar *begin, *p, *err;
- gint priority;
-
+ GList *cur;
+ struct rspamd_dns_resolver *new;
+ gchar *begin, *p, *err;
+ gint priority;
+
new = g_slice_alloc0 (sizeof (struct rspamd_dns_resolver));
new->ev_base = ev_base;
new->request_timeout = cfg->dns_timeout;
new->r = rdns_resolver_new ();
rdns_bind_libevent (new->r, new->ev_base);
rdns_resolver_set_log_level (new->r, cfg->log_level);
- rdns_resolver_set_logger (new->r, (rdns_log_function)rspamd_common_logv, logger);
+ rdns_resolver_set_logger (new->r,
+ (rdns_log_function)rspamd_common_logv,
+ logger);
if (cfg->nameservers == NULL) {
/* Parse resolv.conf */
if (!rdns_resolver_parse_resolv_conf (new->r, "/etc/resolv.conf")) {
- msg_err ("cannot parse resolv.conf and no nameservers defined, so no ways to resolve addresses");
+ msg_err (
+ "cannot parse resolv.conf and no nameservers defined, so no ways to resolve addresses");
return new;
}
}
p = strchr (begin, ':');
if (p != NULL) {
*p = '\0';
- p ++;
+ p++;
priority = strtoul (p, &err, 10);
if (err != NULL && *err != '\0') {
- msg_info ("bad character '%x', must be 'm' or 's' or a numeric priority", *err);
+ msg_info (
+ "bad character '%x', must be 'm' or 's' or a numeric priority",
+ *err);
}
}
else {
priority = 0;
}
- if (!rdns_resolver_add_server (new->r, begin, 53, priority, cfg->dns_io_per_server)) {
+ if (!rdns_resolver_add_server (new->r, begin, 53, priority,
+ cfg->dns_io_per_server)) {
msg_warn ("cannot parse ip address of nameserver: %s", begin);
cur = g_list_next (cur);
continue;
#define RSPAMD_DNS_H
#include "config.h"
-#include "mem_pool.h"
#include "events.h"
#include "logger.h"
+#include "mem_pool.h"
#include "rdns.h"
struct rspamd_dns_resolver;
/**
* Init DNS resolver, params are obtained from a config file or system file /etc/resolv.conf
*/
-struct rspamd_dns_resolver *dns_resolver_init (rspamd_logger_t *logger,
- struct event_base *ev_base, struct rspamd_config *cfg);
+struct rspamd_dns_resolver * dns_resolver_init (rspamd_logger_t *logger,
+ struct event_base *ev_base, struct rspamd_config *cfg);
/**
* Make a DNS request
* @param ... string or ip address based on a request type
* @return TRUE if request was sent.
*/
-gboolean make_dns_request (struct rspamd_dns_resolver *resolver,
- struct rspamd_async_session *session, rspamd_mempool_t *pool,
- dns_callback_type cb, gpointer ud, enum rdns_request_type type, const char *name);
+gboolean make_dns_request (struct rspamd_dns_resolver *resolver,
+ struct rspamd_async_session *session,
+ rspamd_mempool_t *pool,
+ dns_callback_type cb,
+ gpointer ud,
+ enum rdns_request_type type,
+ const char *name);
#endif
*/
#include "config.h"
-#include "main.h"
-#include "map.h"
-#include "filter.h"
#include "dynamic_cfg.h"
+#include "filter.h"
#include "json/jansson.h"
+#include "main.h"
+#include "map.h"
struct dynamic_cfg_symbol {
- gchar *name;
- gdouble value;
+ gchar *name;
+ gdouble value;
};
struct dynamic_cfg_action {
- enum rspamd_metric_action action;
- gdouble value;
+ enum rspamd_metric_action action;
+ gdouble value;
};
struct dynamic_cfg_metric {
- GList *symbols;
- struct dynamic_cfg_action actions[METRIC_ACTION_MAX];
- gchar *name;
+ GList *symbols;
+ struct dynamic_cfg_action actions[METRIC_ACTION_MAX];
+ gchar *name;
};
struct config_json_buf {
- gchar *buf;
- gchar *pos;
- size_t buflen;
- struct rspamd_config *cfg;
- GList *config_metrics;
+ gchar *buf;
+ gchar *pos;
+ size_t buflen;
+ struct rspamd_config *cfg;
+ GList *config_metrics;
};
/**
static void
dynamic_cfg_free (GList *conf_metrics)
{
- GList *cur, *cur_elt;
- struct dynamic_cfg_metric *metric;
- struct dynamic_cfg_symbol *sym;
+ GList *cur, *cur_elt;
+ struct dynamic_cfg_metric *metric;
+ struct dynamic_cfg_symbol *sym;
if (conf_metrics) {
cur = conf_metrics;
static void
apply_dynamic_conf (GList *conf_metrics, struct rspamd_config *cfg)
{
- GList *cur, *cur_elt;
- struct dynamic_cfg_metric *metric;
- struct dynamic_cfg_symbol *sym;
- struct dynamic_cfg_action *act;
- struct metric *real_metric;
- struct metric_action *real_act;
- gdouble *w;
- gint i, j;
+ GList *cur, *cur_elt;
+ struct dynamic_cfg_metric *metric;
+ struct dynamic_cfg_symbol *sym;
+ struct dynamic_cfg_action *act;
+ struct metric *real_metric;
+ struct metric_action *real_act;
+ gdouble *w;
+ gint i, j;
cur = conf_metrics;
while (cur) {
metric = cur->data;
- if ((real_metric = g_hash_table_lookup (cfg->metrics, metric->name)) != NULL) {
+ if ((real_metric =
+ g_hash_table_lookup (cfg->metrics, metric->name)) != NULL) {
cur_elt = metric->symbols;
while (cur_elt) {
sym = cur_elt->data;
- if ((w = g_hash_table_lookup (real_metric->symbols, sym->name)) != NULL) {
+ if ((w =
+ g_hash_table_lookup (real_metric->symbols,
+ sym->name)) != NULL) {
*w = sym->value;
}
else {
- msg_info ("symbol %s is not found in the main configuration", sym->name);
+ msg_info (
+ "symbol %s is not found in the main configuration",
+ sym->name);
}
cur_elt = g_list_next (cur_elt);
}
- for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
+ for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
act = &metric->actions[i];
if (act->value < 0) {
continue;
}
- for (j = METRIC_ACTION_REJECT; j < METRIC_ACTION_MAX; j ++) {
+ for (j = METRIC_ACTION_REJECT; j < METRIC_ACTION_MAX; j++) {
real_act = &real_metric->actions[j];
if (real_act->action == act->action) {
real_act->score = act->value;
}
/* Update required score accordingly to metric's action */
if (act->action == METRIC_ACTION_REJECT) {
- real_metric->actions[METRIC_ACTION_REJECT].score = act->value;
+ real_metric->actions[METRIC_ACTION_REJECT].score =
+ act->value;
}
}
}
}
/* Callbacks for reading json dynamic rules */
-gchar *
-json_config_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+gchar *
+json_config_read_cb (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
- struct config_json_buf *jb;
- gint free, off;
+ struct config_json_buf *jb;
+ gint free, off;
if (data->cur_data == NULL) {
jb = g_malloc (sizeof (struct config_json_buf));
void
json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
{
- struct config_json_buf *jb;
- guint nelts, i, j, selts;
- gint test_act;
- json_t *js, *cur_elt, *cur_nm, *it_val;
- json_error_t je;
- struct dynamic_cfg_metric *cur_metric;
- struct dynamic_cfg_symbol *cur_symbol;
- struct dynamic_cfg_action *cur_action;
+ struct config_json_buf *jb;
+ guint nelts, i, j, selts;
+ gint test_act;
+ json_t *js, *cur_elt, *cur_nm, *it_val;
+ json_error_t je;
+ struct dynamic_cfg_metric *cur_metric;
+ struct dynamic_cfg_symbol *cur_symbol;
+ struct dynamic_cfg_action *cur_action;
if (data->prev_data) {
jb = data->prev_data;
js = json_loads (jb->buf, &je);
if (!js) {
- msg_err ("cannot load json data: parse error %s, on line %d", je.text, je.line);
+ msg_err ("cannot load json data: parse error %s, on line %d",
+ je.text,
+ je.line);
return;
}
cur_nm = json_object_get (cur_elt, "metric");
if (!cur_nm || !json_is_string (cur_nm)) {
- msg_err ("loaded json metric object element has no 'metric' attribute");
+ msg_err (
+ "loaded json metric object element has no 'metric' attribute");
continue;
}
cur_metric = g_slice_alloc0 (sizeof (struct dynamic_cfg_metric));
- for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
+ for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
cur_metric->actions[i].value = -1.0;
}
cur_metric->name = g_strdup (json_string_value (cur_nm));
/* Parse symbols */
if (cur_nm && json_is_array (cur_nm)) {
selts = json_array_size (cur_nm);
- for (j = 0; j < selts; j ++) {
+ for (j = 0; j < selts; j++) {
it_val = json_array_get (cur_nm, j);
if (it_val && json_is_object (it_val)) {
- if (json_object_get (it_val, "name") && json_object_get (it_val, "value")) {
- cur_symbol = g_slice_alloc0 (sizeof (struct dynamic_cfg_symbol));
- cur_symbol->name = g_strdup (json_string_value (json_object_get (it_val, "name")));
- cur_symbol->value = json_number_value (json_object_get (it_val, "value"));
+ if (json_object_get (it_val,
+ "name") && json_object_get (it_val, "value")) {
+ cur_symbol =
+ g_slice_alloc0 (sizeof (struct dynamic_cfg_symbol));
+ cur_symbol->name =
+ g_strdup (json_string_value (json_object_get (it_val,
+ "name")));
+ cur_symbol->value =
+ json_number_value (json_object_get (it_val,
+ "value"));
/* Insert symbol */
- cur_metric->symbols = g_list_prepend (cur_metric->symbols, cur_symbol);
+ cur_metric->symbols = g_list_prepend (
+ cur_metric->symbols,
+ cur_symbol);
}
else {
- msg_info ("json symbol object has no mandatory 'name' and 'value' attributes");
+ msg_info (
+ "json symbol object has no mandatory 'name' and 'value' attributes");
}
}
}
/* Parse actions */
if (cur_nm && json_is_array (cur_nm)) {
selts = json_array_size (cur_nm);
- for (j = 0; j < selts; j ++) {
+ for (j = 0; j < selts; j++) {
it_val = json_array_get (cur_nm, j);
if (it_val && json_is_object (it_val)) {
- if (json_object_get (it_val, "name") && json_object_get (it_val, "value")) {
- if (!check_action_str (json_string_value (json_object_get (it_val, "name")), &test_act)) {
- msg_err ("unknown action: %s", json_string_value (json_object_get (it_val, "name")));
- g_slice_free1 (sizeof (struct dynamic_cfg_action), cur_action);
+ if (json_object_get (it_val,
+ "name") && json_object_get (it_val, "value")) {
+ if (!check_action_str (json_string_value (
+ json_object_get (it_val, "name")), &test_act)) {
+ msg_err ("unknown action: %s",
+ json_string_value (json_object_get (it_val,
+ "name")));
+ g_slice_free1 (sizeof (struct dynamic_cfg_action),
+ cur_action);
continue;
}
cur_action = &cur_metric->actions[test_act];
cur_action->action = test_act;
- cur_action->value = json_number_value (json_object_get (it_val, "value"));
+ cur_action->value =
+ json_number_value (json_object_get (it_val,
+ "value"));
}
else {
- msg_info ("json symbol object has no mandatory 'name' and 'value' attributes");
+ msg_info (
+ "json symbol object has no mandatory 'name' and 'value' attributes");
}
}
}
void
init_dynamic_config (struct rspamd_config *cfg)
{
- struct config_json_buf *jb, **pjb;
+ struct config_json_buf *jb, **pjb;
if (cfg->dynamic_conf == NULL) {
/* No dynamic conf has been specified, so do not try to load it */
jb->buf = NULL;
jb->cfg = cfg;
*pjb = jb;
- if (!add_map (cfg, cfg->dynamic_conf, "Dynamic configuration map", json_config_read_cb, json_config_fin_cb, (void **)pjb)) {
+ if (!add_map (cfg, cfg->dynamic_conf, "Dynamic configuration map",
+ json_config_read_cb, json_config_fin_cb, (void **)pjb)) {
msg_err ("cannot add map for configuration %s", cfg->dynamic_conf);
}
}
static gboolean
dump_dynamic_list (gint fd, GList *rules)
{
- GList *cur, *cur_elt;
- struct dynamic_cfg_metric *metric;
- struct dynamic_cfg_symbol *sym;
- struct dynamic_cfg_action *act;
- FILE *f;
- gint i;
- gboolean start = TRUE;
+ GList *cur, *cur_elt;
+ struct dynamic_cfg_metric *metric;
+ struct dynamic_cfg_symbol *sym;
+ struct dynamic_cfg_action *act;
+ FILE *f;
+ gint i;
+ gboolean start = TRUE;
/* Open buffered stream for the descriptor */
if ((f = fdopen (fd, "a+")) == NULL) {
sym = cur_elt->data;
cur_elt = g_list_next (cur_elt);
if (cur_elt) {
- fprintf (f, " {\"name\": \"%s\",\"value\": %.2f},\n", sym->name, sym->value);
+ fprintf (f,
+ " {\"name\": \"%s\",\"value\": %.2f},\n",
+ sym->name,
+ sym->value);
}
else {
- fprintf (f, " {\"name\": \"%s\",\"value\": %.2f}\n", sym->name, sym->value);
+ fprintf (f,
+ " {\"name\": \"%s\",\"value\": %.2f}\n",
+ sym->name,
+ sym->value);
}
}
if (metric->actions) {
if (metric->actions) {
fprintf (f, " \"actions\": [\n");
- for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
+ for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
act = &metric->actions[i];
if (act->value < 0) {
continue;
}
fprintf (f, " %s{\"name\": \"%s\",\"value\": %.2f}\n",
- (start ? "" : ","), str_action_metric (act->action), act->value);
+ (start ? "" : ","), str_action_metric (
+ act->action), act->value);
if (start) {
start = FALSE;
}
gboolean
dump_dynamic_config (struct rspamd_config *cfg)
{
- struct stat st;
- gchar *dir, pathbuf[PATH_MAX];
- gint fd;
+ struct stat st;
+ gchar *dir, pathbuf[PATH_MAX];
+ gint fd;
if (cfg->dynamic_conf == NULL || cfg->current_dynamic_conf == NULL) {
/* No dynamic conf has been specified, so do not try to dump it */
}
if (stat (cfg->dynamic_conf, &st) == -1) {
- msg_debug ("%s is unavailable: %s", cfg->dynamic_conf, strerror (errno));
- st.st_mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
+ msg_debug ("%s is unavailable: %s", cfg->dynamic_conf,
+ strerror (errno));
+ st.st_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
}
if (access (dir, W_OK | R_OK) == -1) {
msg_warn ("%s is inaccessible: %s", dir, strerror (errno));
g_free (dir);
return FALSE;
}
- rspamd_snprintf (pathbuf, sizeof (pathbuf), "%s%crconf-XXXXXX", dir, G_DIR_SEPARATOR);
+ rspamd_snprintf (pathbuf,
+ sizeof (pathbuf),
+ "%s%crconf-XXXXXX",
+ dir,
+ G_DIR_SEPARATOR);
g_free (dir);
#ifdef HAVE_MKSTEMP
/* Umask is set before */
* @return
*/
gboolean
-add_dynamic_symbol (struct rspamd_config *cfg, const gchar *metric_name, const gchar *symbol, gdouble value)
+add_dynamic_symbol (struct rspamd_config *cfg,
+ const gchar *metric_name,
+ const gchar *symbol,
+ gdouble value)
{
- GList *cur;
- struct dynamic_cfg_metric *metric = NULL;
- struct dynamic_cfg_symbol *sym = NULL;
+ GList *cur;
+ struct dynamic_cfg_metric *metric = NULL;
+ struct dynamic_cfg_symbol *sym = NULL;
if (cfg->dynamic_conf == NULL) {
msg_info ("dynamic conf is disabled");
sym->value = value;
metric->symbols = g_list_prepend (metric->symbols, sym);
metric->name = g_strdup (metric_name);
- cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf, metric);
+ cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf,
+ metric);
msg_debug ("create metric %s for symbol %s", metric_name, symbol);
}
* @return
*/
gboolean
-add_dynamic_action (struct rspamd_config *cfg, const gchar *metric_name, guint action, gdouble value)
+add_dynamic_action (struct rspamd_config *cfg,
+ const gchar *metric_name,
+ guint action,
+ gdouble value)
{
- GList *cur;
- struct dynamic_cfg_metric *metric = NULL;
+ GList *cur;
+ struct dynamic_cfg_metric *metric = NULL;
if (cfg->dynamic_conf == NULL) {
msg_info ("dynamic conf is disabled");
metric = g_slice_alloc0 (sizeof (struct dynamic_cfg_metric));
metric->actions[action].value = value;
metric->name = g_strdup (metric_name);
- cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf, metric);
+ cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf,
+ metric);
msg_debug ("create metric %s for action %d", metric_name, action);
}
#ifndef DYNAMIC_CFG_H_
#define DYNAMIC_CFG_H_
-#include "config.h"
#include "cfg_file.h"
+#include "config.h"
/**
* Init dynamic configuration using map logic and specific configuration
* @param value value of symbol
* @return
*/
-gboolean add_dynamic_symbol (struct rspamd_config *cfg, const gchar *metric, const gchar *symbol, gdouble value);
+gboolean add_dynamic_symbol (struct rspamd_config *cfg,
+ const gchar *metric,
+ const gchar *symbol,
+ gdouble value);
/**
* @param value value of symbol
* @return
*/
-gboolean add_dynamic_action (struct rspamd_config *cfg, const gchar *metric, guint action, gdouble value);
+gboolean add_dynamic_action (struct rspamd_config *cfg,
+ const gchar *metric,
+ guint action,
+ gdouble value);
#endif /* DYNAMIC_CFG_H_ */
*/
#include "config.h"
-#include "main.h"
#include "events.h"
+#include "main.h"
static gboolean
rspamd_event_equal (gconstpointer a, gconstpointer b)
{
- const struct rspamd_async_event *ev1 = a, *ev2 = b;
+ const struct rspamd_async_event *ev1 = a, *ev2 = b;
if (ev1->fin == ev2->fin) {
return ev1->user_data == ev2->user_data;
static guint
rspamd_event_hash (gconstpointer a)
{
- const struct rspamd_async_event *ev = a;
+ const struct rspamd_async_event *ev = a;
return GPOINTER_TO_UINT (ev->user_data);
}
static void
event_mutex_free (gpointer data)
{
- GMutex *mtx = data;
+ GMutex *mtx = data;
g_mutex_free (mtx);
}
static void
event_cond_free (gpointer data)
{
- GCond *cond = data;
+ GCond *cond = data;
g_cond_free (cond);
}
#endif
-struct rspamd_async_session *
+struct rspamd_async_session *
new_async_session (rspamd_mempool_t * pool, session_finalizer_t fin,
- event_finalizer_t restore, event_finalizer_t cleanup, void *user_data)
+ event_finalizer_t restore, event_finalizer_t cleanup, void *user_data)
{
- struct rspamd_async_session *new;
+ struct rspamd_async_session *new;
new = rspamd_mempool_alloc (pool, sizeof (struct rspamd_async_session));
new->pool = pool;
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
new->mtx = g_mutex_new ();
new->cond = g_cond_new ();
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) event_mutex_free, new->mtx);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) event_cond_free, new->cond);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) event_mutex_free,
+ new->mtx);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) event_cond_free,
+ new->cond);
#else
new->mtx = rspamd_mempool_alloc (pool, sizeof (GMutex));
g_mutex_init (new->mtx);
new->cond = rspamd_mempool_alloc (pool, sizeof (GCond));
g_cond_init (new->cond);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_mutex_clear, new->mtx);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_cond_clear, new->cond);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_mutex_clear,
+ new->mtx);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_cond_clear,
+ new->cond);
#endif
new->threads = 0;
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, new->events);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ new->events);
return new;
}
void
-register_async_event (struct rspamd_async_session *session, event_finalizer_t fin, void *user_data, GQuark subsystem)
+register_async_event (struct rspamd_async_session *session,
+ event_finalizer_t fin,
+ void *user_data,
+ GQuark subsystem)
{
- struct rspamd_async_event *new;
+ struct rspamd_async_event *new;
if (session == NULL) {
msg_info ("session is NULL");
}
g_mutex_lock (session->mtx);
- new = rspamd_mempool_alloc (session->pool, sizeof (struct rspamd_async_event));
+ new = rspamd_mempool_alloc (session->pool,
+ sizeof (struct rspamd_async_event));
new->fin = fin;
new->user_data = user_data;
new->subsystem = subsystem;
g_hash_table_insert (session->events, new, new);
- msg_debug ("added event: %p, pending %d events, subsystem: %s", user_data, g_hash_table_size (session->events),
- g_quark_to_string (subsystem));
+ msg_debug ("added event: %p, pending %d events, subsystem: %s",
+ user_data,
+ g_hash_table_size (session->events),
+ g_quark_to_string (subsystem));
g_mutex_unlock (session->mtx);
}
void
-remove_normal_event (struct rspamd_async_session *session, event_finalizer_t fin, void *ud)
+remove_normal_event (struct rspamd_async_session *session,
+ event_finalizer_t fin,
+ void *ud)
{
- struct rspamd_async_event search_ev, *found_ev;
+ struct rspamd_async_event search_ev, *found_ev;
if (session == NULL) {
msg_info ("session is NULL");
/* Search for event */
search_ev.fin = fin;
search_ev.user_data = ud;
- if ((found_ev = g_hash_table_lookup (session->events, &search_ev)) != NULL) {
+ if ((found_ev =
+ g_hash_table_lookup (session->events, &search_ev)) != NULL) {
g_hash_table_remove (session->events, found_ev);
msg_debug ("removed event: %p, subsystem: %s, pending %d events", ud,
- g_quark_to_string (found_ev->subsystem), g_hash_table_size (session->events));
+ g_quark_to_string (found_ev->subsystem),
+ g_hash_table_size (session->events));
/* Remove event */
fin (ud);
}
static gboolean
rspamd_session_destroy (gpointer k, gpointer v, gpointer unused)
{
- struct rspamd_async_event *ev = v;
+ struct rspamd_async_event *ev = v;
/* Call event's finalizer */
msg_debug ("removed event on destroy: %p, subsystem: %s", ev->user_data,
- g_quark_to_string (ev->subsystem));
+ g_quark_to_string (ev->subsystem));
if (ev->fin != NULL) {
ev->fin (ev->user_data);
g_mutex_lock (session->mtx);
if (session->threads > 0) {
- /* Wait for conditional variable to finish processing */
+ /* Wait for conditional variable to finish processing */
g_mutex_unlock (session->mtx);
g_cond_wait (session->cond, session->mtx);
}
session->wanna_die = TRUE;
- g_hash_table_foreach_remove (session->events, rspamd_session_destroy, session);
+ g_hash_table_foreach_remove (session->events,
+ rspamd_session_destroy,
+ session);
/* Mutex can be destroyed here */
g_mutex_unlock (session->mtx);
}
if (session->fin != NULL) {
g_mutex_unlock (session->mtx);
- if (! session->fin (session->user_data)) {
+ if (!session->fin (session->user_data)) {
/* Session finished incompletely, perform restoration */
if (session->restore != NULL) {
session->restore (session->user_data);
* @param user_data abstract user data
* @return
*/
-struct rspamd_async_session *new_async_session (rspamd_mempool_t *pool,
- session_finalizer_t fin, event_finalizer_t restore,
- event_finalizer_t cleanup, void *user_data);
+struct rspamd_async_session * new_async_session (rspamd_mempool_t *pool,
+ session_finalizer_t fin, event_finalizer_t restore,
+ event_finalizer_t cleanup, void *user_data);
/**
* Insert new event to the session
* @param forced unused
*/
void register_async_event (struct rspamd_async_session *session,
- event_finalizer_t fin, void *user_data, GQuark subsystem);
+ event_finalizer_t fin, void *user_data, GQuark subsystem);
/**
* Remove normal event
* @param fin final callback
* @param ud user data object
*/
-void remove_normal_event (struct rspamd_async_session *session, event_finalizer_t fin, void *ud);
+void remove_normal_event (struct rspamd_async_session *session,
+ event_finalizer_t fin,
+ void *ud);
/**
* Must be called at the end of session, it calls fin functions for all non-forced callbacks
- * @return true if the whole session was destroyed and false if there are forced events
+ * @return true if the whole session was destroyed and false if there are forced events
*/
gboolean destroy_session (struct rspamd_async_session *session);
*/
#include "config.h"
-#include "util.h"
+#include "html.h"
#include "main.h"
#include "message.h"
-#include "html.h"
#include "url.h"
+#include "util.h"
-static sig_atomic_t tags_sorted = 0;
+static sig_atomic_t tags_sorted = 0;
-static struct html_tag tag_defs[] = {
+static struct html_tag tag_defs[] = {
/* W3C defined elements */
{Tag_A, "a", (CM_INLINE)},
{Tag_ABBR, "abbr", (CM_INLINE)},
{Tag_META, "meta", (CM_HEAD | CM_EMPTY)},
{Tag_NOFRAMES, "noframes", (CM_BLOCK | CM_FRAMES)},
{Tag_NOSCRIPT, "noscript", (CM_BLOCK | CM_INLINE | CM_MIXED)},
- {Tag_OBJECT, "object", (CM_OBJECT | CM_HEAD | CM_IMG | CM_INLINE | CM_PARAM)},
+ {Tag_OBJECT, "object",
+ (CM_OBJECT | CM_HEAD | CM_IMG | CM_INLINE | CM_PARAM)},
{Tag_OL, "ol", (CM_BLOCK)},
{Tag_OPTGROUP, "optgroup", (CM_FIELD | CM_OPT)},
{Tag_OPTION, "option", (CM_FIELD | CM_OPT)},
{Tag_WBR, "wbr", (CM_INLINE | CM_EMPTY)},
};
-static sig_atomic_t entities_sorted = 0;
+static sig_atomic_t entities_sorted = 0;
struct _entity;
-typedef struct _entity entity;
+typedef struct _entity entity;
struct _entity {
- gchar *name;
- uint code;
- gchar *replacement;
+ gchar *name;
+ uint code;
+ gchar *replacement;
};
-static entity entities_defs[] = {
+static entity entities_defs[] = {
/*
- ** Markup pre-defined character entities
- */
+ ** Markup pre-defined character entities
+ */
{"quot", 34, "\""},
{"amp", 38, "&"},
{"apos", 39, "'"},
{"gt", 62, ">"},
/*
- ** Latin-1 character entities
- */
+ ** Latin-1 character entities
+ */
{"nbsp", 160, " "},
{"iexcl", 161, "!"},
{"cent", 162, "cent"},
{"yuml", 255, "y"},
/*
- ** Extended Entities defined in HTML 4: Symbols
- */
+ ** Extended Entities defined in HTML 4: Symbols
+ */
{"fnof", 402, "f"},
{"Alpha", 913, "alpha"},
{"Beta", 914, "beta"},
{"diams", 9830, NULL},
/*
- ** Extended Entities defined in HTML 4: Special (less Markup at top)
- */
+ ** Extended Entities defined in HTML 4: Special (less Markup at top)
+ */
{"OElig", 338, NULL},
{"oelig", 339, NULL},
{"Scaron", 352, NULL},
static gint
tag_cmp (const void *m1, const void *m2)
{
- const struct html_tag *p1 = m1;
- const struct html_tag *p2 = m2;
+ const struct html_tag *p1 = m1;
+ const struct html_tag *p2 = m2;
return g_ascii_strcasecmp (p1->name, p2->name);
}
static gint
entity_cmp (const void *m1, const void *m2)
{
- const entity *p1 = m1;
- const entity *p2 = m2;
+ const entity *p1 = m1;
+ const entity *p2 = m2;
return g_ascii_strcasecmp (p1->name, p2->name);
}
static gint
entity_cmp_num (const void *m1, const void *m2)
{
- const entity *p1 = m1;
- const entity *p2 = m2;
+ const entity *p1 = m1;
+ const entity *p2 = m2;
return p1->code - p2->code;
}
-static GNode *
+static GNode *
construct_html_node (rspamd_mempool_t * pool, gchar *text, gsize tag_len)
{
- struct html_node *html;
- GNode *n = NULL;
- struct html_tag key, *found;
- gchar t;
+ struct html_node *html;
+ GNode *n = NULL;
+ struct html_tag key, *found;
+ gchar t;
if (text == NULL || *text == '\0') {
return NULL;
}
/* Check xml tag */
- if (*text == '?' && g_ascii_strncasecmp (text + 1, "xml", sizeof ("xml") - 1) == 0) {
+ if (*text == '?' &&
+ g_ascii_strncasecmp (text + 1, "xml", sizeof ("xml") - 1) == 0) {
html->flags |= FL_XML;
html->tag = NULL;
}
/* Find end of tag name */
key.name = text;
- while (*text && g_ascii_isalnum (*(++text)));
+ while (*text && g_ascii_isalnum (*(++text))) ;
t = *text;
*text = '\0';
/* Match tag id by tag name */
- if ((found = bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs), sizeof (struct html_tag), tag_cmp)) != NULL) {
+ if ((found =
+ bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs),
+ sizeof (struct html_tag), tag_cmp)) != NULL) {
*text = t;
html->tag = found;
}
return n;
}
-static gboolean
+static gboolean
check_balance (GNode * node, GNode ** cur_level)
{
- struct html_node *arg = node->data, *tmp;
- GNode *cur;
+ struct html_node *arg = node->data, *tmp;
+ GNode *cur;
if (arg->flags & FL_CLOSING) {
/* First of all check whether this tag is closing tag for parent node */
cur = node->parent;
while (cur && cur->data) {
tmp = cur->data;
- if ((tmp->tag && arg->tag) && tmp->tag->id == arg->tag->id && (tmp->flags & FL_CLOSED) == 0) {
+ if ((tmp->tag &&
+ arg->tag) && tmp->tag->id == arg->tag->id &&
+ (tmp->flags & FL_CLOSED) == 0) {
tmp->flags |= FL_CLOSED;
/* Destroy current node as we find corresponding parent node */
g_node_destroy (node);
return FALSE;
}
-struct html_tag *
+struct html_tag *
get_tag_by_name (const gchar *name)
{
- struct html_tag key;
+ struct html_tag key;
key.name = name;
- return bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs), sizeof (struct html_tag), tag_cmp);
+ return bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs),
+ sizeof (struct html_tag), tag_cmp);
}
/* Decode HTML entitles in text */
void
decode_entitles (gchar *s, guint * len)
{
- guint l, rep_len;
- gchar *t = s; /* t - tortoise */
- gchar *h = s; /* h - hare */
- gchar *e = s;
- gchar *end_ptr;
- gint state = 0, val, base;
- entity *found, key;
+ guint l, rep_len;
+ gchar *t = s; /* t - tortoise */
+ gchar *h = s; /* h - hare */
+ gchar *e = s;
+ gchar *end_ptr;
+ gint state = 0, val, base;
+ entity *found, key;
if (len == NULL || *len == 0) {
l = strlen (s);
while (h - s < (gint)l) {
switch (state) {
- /* Out of entitle */
+ /* Out of entitle */
case 0:
if (*h == '&') {
state = 1;
key.name = e + 1;
*h = '\0';
- if (*(e + 1) != '#' && (found = bsearch (&key, entities_defs, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp)) != NULL) {
+ if (*(e + 1) != '#' &&
+ (found =
+ bsearch (&key, entities_defs, G_N_ELEMENTS (entities_defs),
+ sizeof (entity), entity_cmp)) != NULL) {
if (found->replacement) {
rep_len = strlen (found->replacement);
memcpy (t, found->replacement, rep_len);
else {
/* Search for a replacement */
key.code = val;
- found = bsearch (&key, entities_defs_num, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp_num);
+ found =
+ bsearch (&key, entities_defs_num, G_N_ELEMENTS (
+ entities_defs), sizeof (entity),
+ entity_cmp_num);
if (found) {
if (found->replacement) {
rep_len = strlen (found->replacement);
}
static void
-check_phishing (struct rspamd_task *task, struct uri *href_url, const gchar *url_text, gsize remain, tag_id_t id)
+check_phishing (struct rspamd_task *task,
+ struct uri *href_url,
+ const gchar *url_text,
+ gsize remain,
+ tag_id_t id)
{
- struct uri *new;
- gchar *url_str;
- const gchar *p, *c;
- gchar tagbuf[128];
- struct html_tag *tag;
- gsize len = 0;
- gint rc;
+ struct uri *new;
+ gchar *url_str;
+ const gchar *p, *c;
+ gchar tagbuf[128];
+ struct html_tag *tag;
+ gsize len = 0;
+ gint rc;
p = url_text;
while (len < remain) {
}
while (len < remain) {
if (!g_ascii_isspace (*p) && *p != '>') {
- p ++;
- len ++;
+ p++;
+ len++;
}
else {
break;
else if (tag->id == Tag_IMG) {
/* We should ignore IMG tag here */
while (len < remain && *p != '>' && *p != '<') {
- p ++;
- len ++;
+ p++;
+ len++;
}
if (*p == '>' && len < remain) {
- p ++;
+ p++;
}
remain -= p - url_text;
}
}
}
- len ++;
- p ++;
+ len++;
+ p++;
}
- if (url_try_text (task->task_pool, url_text, len, NULL, NULL, &url_str, TRUE) && url_str != NULL) {
+ if (url_try_text (task->task_pool, url_text, len, NULL, NULL, &url_str,
+ TRUE) && url_str != NULL) {
new = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct uri));
if (new != NULL) {
g_strstrip (url_str);
rc = parse_uri (new, url_str, task->task_pool);
- if (rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc == URI_ERRNO_NO_HOST_SLASH) {
+ if (rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc ==
+ URI_ERRNO_NO_HOST_SLASH) {
if (g_ascii_strncasecmp (href_url->host, new->host,
- MAX (href_url->hostlen, new->hostlen)) != 0) {
+ MAX (href_url->hostlen, new->hostlen)) != 0) {
/* Special check for urls beginning with 'www' */
if (new->hostlen > 4 && href_url->hostlen > 4) {
p = new->host;
}
}
else {
- msg_info ("extract of url '%s' failed: %s", url_str, url_strerror (rc));
+ msg_info ("extract of url '%s' failed: %s",
+ url_str,
+ url_strerror (rc));
}
}
}
}
static void
-parse_tag_url (struct rspamd_task *task, struct mime_text_part *part, tag_id_t id,
- gchar *tag_text, gsize tag_len, gsize remain)
+parse_tag_url (struct rspamd_task *task,
+ struct mime_text_part *part,
+ tag_id_t id,
+ gchar *tag_text,
+ gsize tag_len,
+ gsize remain)
{
- gchar *c = NULL, *p, *url_text;
- gint len, rc;
- struct uri *url;
- gboolean got_single_quote = FALSE, got_double_quote = FALSE;
+ gchar *c = NULL, *p, *url_text;
+ gint len, rc;
+ struct uri *url;
+ gboolean got_single_quote = FALSE, got_double_quote = FALSE;
/* For A tags search for href= and for IMG tags search for src= */
if (id == Tag_A) {
len++;
}
}
- else if (g_ascii_isspace (*p) || *p == '>' || (*p == '/' && *(p + 1) == '>') || *p == '\r' || *p == '\n') {
+ else if (g_ascii_isspace (*p) || *p == '>' ||
+ (*p == '/' && *(p + 1) == '>') || *p == '\r' || *p == '\n') {
break;
}
else {
rspamd_strlcpy (url_text, c, len + 1);
decode_entitles (url_text, NULL);
- if (g_ascii_strncasecmp (url_text, "http://", sizeof ("http://") - 1) != 0 &&
- g_ascii_strncasecmp (url_text, "www", sizeof ("www") - 1) != 0 &&
- g_ascii_strncasecmp (url_text, "ftp://", sizeof ("ftp://") - 1) != 0 &&
- g_ascii_strncasecmp (url_text, "mailto:", sizeof ("mailto:") - 1) != 0) {
+ if (g_ascii_strncasecmp (url_text, "http://",
+ sizeof ("http://") - 1) != 0 &&
+ g_ascii_strncasecmp (url_text, "www",
+ sizeof ("www") - 1) != 0 &&
+ g_ascii_strncasecmp (url_text, "ftp://",
+ sizeof ("ftp://") - 1) != 0 &&
+ g_ascii_strncasecmp (url_text, "mailto:",
+ sizeof ("mailto:") - 1) != 0) {
return;
}
url = rspamd_mempool_alloc (task->task_pool, sizeof (struct uri));
rc = parse_uri (url, url_text, task->task_pool);
- if (rc != URI_ERRNO_EMPTY && rc != URI_ERRNO_NO_HOST && url->hostlen != 0) {
+ if (rc != URI_ERRNO_EMPTY && rc != URI_ERRNO_NO_HOST && url->hostlen !=
+ 0) {
/*
* Check for phishing
*/
if ((p = strchr (c, '>')) != NULL && id == Tag_A) {
- p ++;
+ p++;
check_phishing (task, url, p, remain - (p - tag_text), id);
}
if (g_tree_lookup (task->urls, url) == NULL) {
}
gboolean
-add_html_node (struct rspamd_task *task, rspamd_mempool_t * pool, struct mime_text_part *part,
- gchar *tag_text, gsize tag_len, gsize remain, GNode ** cur_level)
+add_html_node (struct rspamd_task *task,
+ rspamd_mempool_t * pool,
+ struct mime_text_part *part,
+ gchar *tag_text,
+ gsize tag_len,
+ gsize remain,
+ GNode ** cur_level)
{
- GNode *new;
- struct html_node *data;
+ GNode *new;
+ struct html_node *data;
if (!tags_sorted) {
- qsort (tag_defs, G_N_ELEMENTS (tag_defs), sizeof (struct html_tag), tag_cmp);
+ qsort (tag_defs, G_N_ELEMENTS (
+ tag_defs), sizeof (struct html_tag), tag_cmp);
tags_sorted = 1;
}
if (!entities_sorted) {
- qsort (entities_defs, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp);
+ qsort (entities_defs, G_N_ELEMENTS (
+ entities_defs), sizeof (entity), entity_cmp);
memcpy (entities_defs_num, entities_defs, sizeof (entities_defs));
- qsort (entities_defs_num, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp_num);
+ qsort (entities_defs_num, G_N_ELEMENTS (
+ entities_defs), sizeof (entity), entity_cmp_num);
entities_sorted = 1;
}
new = g_node_new (NULL);
*cur_level = new;
part->html_nodes = new;
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_node_destroy, part->html_nodes);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_node_destroy,
+ part->html_nodes);
/* Call once again with root node */
- return add_html_node (task, pool, part, tag_text, tag_len, remain, cur_level);
+ return add_html_node (task,
+ pool,
+ part,
+ tag_text,
+ tag_len,
+ remain,
+ cur_level);
}
else {
new = construct_html_node (pool, tag_text, tag_len);
if (new == NULL) {
- debug_task ("cannot construct HTML node for text '%*s'", tag_len, tag_text);
+ debug_task ("cannot construct HTML node for text '%*s'",
+ tag_len,
+ tag_text);
return FALSE;
}
data = new->data;
- if (data->tag && (data->tag->id == Tag_A || data->tag->id == Tag_IMG) && ((data->flags & FL_CLOSING) == 0)) {
- parse_tag_url (task, part, data->tag->id, tag_text, tag_len, remain);
+ if (data->tag &&
+ (data->tag->id == Tag_A ||
+ data->tag->id == Tag_IMG) && ((data->flags & FL_CLOSING) == 0)) {
+ parse_tag_url (task, part, data->tag->id, tag_text, tag_len,
+ remain);
}
if (data->flags & FL_CLOSING) {
}
g_node_append (*cur_level, new);
if (!check_balance (new, cur_level)) {
- debug_task ("mark part as unbalanced as it has not pairable closing tags");
+ debug_task (
+ "mark part as unbalanced as it has not pairable closing tags");
part->is_balanced = FALSE;
}
}
}
/* Skip some tags */
if (data->tag && (data->tag->id == Tag_STYLE ||
- data->tag->id == Tag_SCRIPT ||
- data->tag->id == Tag_OBJECT ||
- data->tag->id == Tag_TITLE)) {
+ data->tag->id == Tag_SCRIPT ||
+ data->tag->id == Tag_OBJECT ||
+ data->tag->id == Tag_TITLE)) {
return FALSE;
}
}
/* Known HTML tags */
typedef enum
{
- Tag_UNKNOWN, /**< Unknown tag! */
- Tag_A, /**< A */
- Tag_ABBR, /**< ABBR */
- Tag_ACRONYM, /**< ACRONYM */
- Tag_ADDRESS, /**< ADDRESS */
- Tag_ALIGN, /**< ALIGN */
- Tag_APPLET, /**< APPLET */
- Tag_AREA, /**< AREA */
- Tag_B, /**< B */
- Tag_BASE, /**< BASE */
- Tag_BASEFONT, /**< BASEFONT */
- Tag_BDO, /**< BDO */
- Tag_BGSOUND, /**< BGSOUND */
- Tag_BIG, /**< BIG */
- Tag_BLINK, /**< BLINK */
- Tag_BLOCKQUOTE, /**< BLOCKQUOTE */
- Tag_BODY, /**< BODY */
- Tag_BR, /**< BR */
- Tag_BUTTON, /**< BUTTON */
- Tag_CAPTION, /**< CAPTION */
- Tag_CENTER, /**< CENTER */
- Tag_CITE, /**< CITE */
- Tag_CODE, /**< CODE */
- Tag_COL, /**< COL */
- Tag_COLGROUP, /**< COLGROUP */
- Tag_COMMENT, /**< COMMENT */
- Tag_DD, /**< DD */
- Tag_DEL, /**< DEL */
- Tag_DFN, /**< DFN */
- Tag_DIR, /**< DIR */
- Tag_DIV, /**< DIF */
- Tag_DL, /**< DL */
- Tag_DT, /**< DT */
- Tag_EM, /**< EM */
- Tag_EMBED, /**< EMBED */
- Tag_FIELDSET, /**< FIELDSET */
- Tag_FONT, /**< FONT */
- Tag_FORM, /**< FORM */
- Tag_FRAME, /**< FRAME */
- Tag_FRAMESET, /**< FRAMESET */
- Tag_H1, /**< H1 */
- Tag_H2, /**< H2 */
- Tag_H3, /**< H3 */
- Tag_H4, /**< H4 */
- Tag_H5, /**< H5 */
- Tag_H6, /**< H6 */
- Tag_HEAD, /**< HEAD */
- Tag_HR, /**< HR */
- Tag_HTML, /**< HTML */
- Tag_I, /**< I */
- Tag_IFRAME, /**< IFRAME */
- Tag_ILAYER, /**< ILAYER */
- Tag_IMG, /**< IMG */
- Tag_INPUT, /**< INPUT */
- Tag_INS, /**< INS */
- Tag_ISINDEX, /**< ISINDEX */
- Tag_KBD, /**< KBD */
- Tag_KEYGEN, /**< KEYGEN */
- Tag_LABEL, /**< LABEL */
- Tag_LAYER, /**< LAYER */
- Tag_LEGEND, /**< LEGEND */
- Tag_LI, /**< LI */
- Tag_LINK, /**< LINK */
- Tag_LISTING, /**< LISTING */
- Tag_MAP, /**< MAP */
- Tag_MARQUEE, /**< MARQUEE */
- Tag_MENU, /**< MENU */
- Tag_META, /**< META */
- Tag_MULTICOL, /**< MULTICOL */
- Tag_NOBR, /**< NOBR */
- Tag_NOEMBED, /**< NOEMBED */
- Tag_NOFRAMES, /**< NOFRAMES */
- Tag_NOLAYER, /**< NOLAYER */
- Tag_NOSAVE, /**< NOSAVE */
- Tag_NOSCRIPT, /**< NOSCRIPT */
- Tag_OBJECT, /**< OBJECT */
- Tag_OL, /**< OL */
- Tag_OPTGROUP, /**< OPTGROUP */
- Tag_OPTION, /**< OPTION */
- Tag_P, /**< P */
- Tag_PARAM, /**< PARAM */
- Tag_PLAINTEXT,/**< PLAINTEXT */
- Tag_PRE, /**< PRE */
- Tag_Q, /**< Q */
- Tag_RB, /**< RB */
- Tag_RBC, /**< RBC */
- Tag_RP, /**< RP */
- Tag_RT, /**< RT */
- Tag_RTC, /**< RTC */
- Tag_RUBY, /**< RUBY */
- Tag_S, /**< S */
- Tag_SAMP, /**< SAMP */
- Tag_SCRIPT, /**< SCRIPT */
- Tag_SELECT, /**< SELECT */
- Tag_SERVER, /**< SERVER */
- Tag_SERVLET, /**< SERVLET */
- Tag_SMALL, /**< SMALL */
- Tag_SPACER, /**< SPACER */
- Tag_SPAN, /**< SPAN */
- Tag_STRIKE, /**< STRIKE */
- Tag_STRONG, /**< STRONG */
- Tag_STYLE, /**< STYLE */
- Tag_SUB, /**< SUB */
- Tag_SUP, /**< SUP */
- Tag_TABLE, /**< TABLE */
- Tag_TBODY, /**< TBODY */
- Tag_TD, /**< TD */
- Tag_TEXTAREA, /**< TEXTAREA */
- Tag_TFOOT, /**< TFOOT */
- Tag_TH, /**< TH */
- Tag_THEAD, /**< THEAD */
- Tag_TITLE, /**< TITLE */
- Tag_TR, /**< TR */
- Tag_TT, /**< TT */
- Tag_U, /**< U */
- Tag_UL, /**< UL */
- Tag_VAR, /**< VAR */
- Tag_WBR, /**< WBR */
- Tag_XMP, /**< XMP */
- Tag_XML, /**< XML */
- Tag_NEXTID, /**< NEXTID */
+ Tag_UNKNOWN, /**< Unknown tag! */
+ Tag_A, /**< A */
+ Tag_ABBR, /**< ABBR */
+ Tag_ACRONYM, /**< ACRONYM */
+ Tag_ADDRESS, /**< ADDRESS */
+ Tag_ALIGN, /**< ALIGN */
+ Tag_APPLET, /**< APPLET */
+ Tag_AREA, /**< AREA */
+ Tag_B, /**< B */
+ Tag_BASE, /**< BASE */
+ Tag_BASEFONT, /**< BASEFONT */
+ Tag_BDO, /**< BDO */
+ Tag_BGSOUND, /**< BGSOUND */
+ Tag_BIG, /**< BIG */
+ Tag_BLINK, /**< BLINK */
+ Tag_BLOCKQUOTE, /**< BLOCKQUOTE */
+ Tag_BODY, /**< BODY */
+ Tag_BR, /**< BR */
+ Tag_BUTTON, /**< BUTTON */
+ Tag_CAPTION, /**< CAPTION */
+ Tag_CENTER, /**< CENTER */
+ Tag_CITE, /**< CITE */
+ Tag_CODE, /**< CODE */
+ Tag_COL, /**< COL */
+ Tag_COLGROUP, /**< COLGROUP */
+ Tag_COMMENT, /**< COMMENT */
+ Tag_DD, /**< DD */
+ Tag_DEL, /**< DEL */
+ Tag_DFN, /**< DFN */
+ Tag_DIR, /**< DIR */
+ Tag_DIV, /**< DIF */
+ Tag_DL, /**< DL */
+ Tag_DT, /**< DT */
+ Tag_EM, /**< EM */
+ Tag_EMBED, /**< EMBED */
+ Tag_FIELDSET, /**< FIELDSET */
+ Tag_FONT, /**< FONT */
+ Tag_FORM, /**< FORM */
+ Tag_FRAME, /**< FRAME */
+ Tag_FRAMESET, /**< FRAMESET */
+ Tag_H1, /**< H1 */
+ Tag_H2, /**< H2 */
+ Tag_H3, /**< H3 */
+ Tag_H4, /**< H4 */
+ Tag_H5, /**< H5 */
+ Tag_H6, /**< H6 */
+ Tag_HEAD, /**< HEAD */
+ Tag_HR, /**< HR */
+ Tag_HTML, /**< HTML */
+ Tag_I, /**< I */
+ Tag_IFRAME, /**< IFRAME */
+ Tag_ILAYER, /**< ILAYER */
+ Tag_IMG, /**< IMG */
+ Tag_INPUT, /**< INPUT */
+ Tag_INS, /**< INS */
+ Tag_ISINDEX, /**< ISINDEX */
+ Tag_KBD, /**< KBD */
+ Tag_KEYGEN, /**< KEYGEN */
+ Tag_LABEL, /**< LABEL */
+ Tag_LAYER, /**< LAYER */
+ Tag_LEGEND, /**< LEGEND */
+ Tag_LI, /**< LI */
+ Tag_LINK, /**< LINK */
+ Tag_LISTING, /**< LISTING */
+ Tag_MAP, /**< MAP */
+ Tag_MARQUEE, /**< MARQUEE */
+ Tag_MENU, /**< MENU */
+ Tag_META, /**< META */
+ Tag_MULTICOL, /**< MULTICOL */
+ Tag_NOBR, /**< NOBR */
+ Tag_NOEMBED, /**< NOEMBED */
+ Tag_NOFRAMES, /**< NOFRAMES */
+ Tag_NOLAYER, /**< NOLAYER */
+ Tag_NOSAVE, /**< NOSAVE */
+ Tag_NOSCRIPT, /**< NOSCRIPT */
+ Tag_OBJECT, /**< OBJECT */
+ Tag_OL, /**< OL */
+ Tag_OPTGROUP, /**< OPTGROUP */
+ Tag_OPTION, /**< OPTION */
+ Tag_P, /**< P */
+ Tag_PARAM, /**< PARAM */
+ Tag_PLAINTEXT, /**< PLAINTEXT */
+ Tag_PRE, /**< PRE */
+ Tag_Q, /**< Q */
+ Tag_RB, /**< RB */
+ Tag_RBC, /**< RBC */
+ Tag_RP, /**< RP */
+ Tag_RT, /**< RT */
+ Tag_RTC, /**< RTC */
+ Tag_RUBY, /**< RUBY */
+ Tag_S, /**< S */
+ Tag_SAMP, /**< SAMP */
+ Tag_SCRIPT, /**< SCRIPT */
+ Tag_SELECT, /**< SELECT */
+ Tag_SERVER, /**< SERVER */
+ Tag_SERVLET, /**< SERVLET */
+ Tag_SMALL, /**< SMALL */
+ Tag_SPACER, /**< SPACER */
+ Tag_SPAN, /**< SPAN */
+ Tag_STRIKE, /**< STRIKE */
+ Tag_STRONG, /**< STRONG */
+ Tag_STYLE, /**< STYLE */
+ Tag_SUB, /**< SUB */
+ Tag_SUP, /**< SUP */
+ Tag_TABLE, /**< TABLE */
+ Tag_TBODY, /**< TBODY */
+ Tag_TD, /**< TD */
+ Tag_TEXTAREA, /**< TEXTAREA */
+ Tag_TFOOT, /**< TFOOT */
+ Tag_TH, /**< TH */
+ Tag_THEAD, /**< THEAD */
+ Tag_TITLE, /**< TITLE */
+ Tag_TR, /**< TR */
+ Tag_TT, /**< TT */
+ Tag_U, /**< U */
+ Tag_UL, /**< UL */
+ Tag_VAR, /**< VAR */
+ Tag_WBR, /**< WBR */
+ Tag_XMP, /**< XMP */
+ Tag_XML, /**< XML */
+ Tag_NEXTID, /**< NEXTID */
- N_TAGS /**< Must be last */
+ N_TAGS /**< Must be last */
} tag_id_t;
#define CM_UNKNOWN 0
#define CM_IMG (1 << 16)
/* Elements with inline and block model. Used to avoid calling InlineDup. */
#define CM_MIXED (1 << 17)
-/* Elements whose content needs to be indented only if containing one
+/* Elements whose content needs to be indented only if containing one
CM_BLOCK element. */
#define CM_NO_INDENT (1 << 18)
/* Elements that are obsolete (such as "dir", "menu"). */
#define CM_OMITST (1 << 21)
/* XML tag */
-#define FL_XML (1 << 0)
+#define FL_XML (1 << 0)
/* Closing tag */
-#define FL_CLOSING (1 << 1)
+#define FL_CLOSING (1 << 1)
/* Fully closed tag (e.g. <a attrs />) */
-#define FL_CLOSED (1 << 2)
+#define FL_CLOSED (1 << 2)
struct html_tag {
tag_id_t id;
/*
* Add a single node to the tags tree
*/
-gboolean add_html_node (struct rspamd_task *task, rspamd_mempool_t *pool,
- struct mime_text_part *part, gchar *tag_text, gsize tag_len, gsize remain, GNode **cur_level);
+gboolean add_html_node (struct rspamd_task *task,
+ rspamd_mempool_t *pool,
+ struct mime_text_part *part,
+ gchar *tag_text,
+ gsize tag_len,
+ gsize remain,
+ GNode **cur_level);
/*
* Get tag structure by its name (binary search is used)
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "cfg_file.h"
#include "config.h"
#include "main.h"
-#include "util.h"
-#include "cfg_file.h"
#include "message.h"
+#include "util.h"
/* Max line size */
#define OUTBUFSIZ BUFSIZ
* described below
*/
#define MSG_CMD_CHECK "check"
-/*
+/*
* Check if message is spam or not, and return score plus list
* of symbols hit
*/
#define DELIVER_TO_HEADER "Deliver-To"
#define NO_LOG_HEADER "Log"
-static GList *custom_commands = NULL;
+static GList *custom_commands = NULL;
/*
static gchar *
rspamd_protocol_escape_braces (GString *in)
{
- gint len = 0;
- gchar *orig, *p;
+ gint len = 0;
+ gchar *orig, *p;
orig = in->str;
- while ((g_ascii_isspace (*orig) || *orig == '<') && orig - in->str < (gint)in->len) {
- orig ++;
+ while ((g_ascii_isspace (*orig) || *orig ==
+ '<') && orig - in->str < (gint)in->len) {
+ orig++;
}
g_string_erase (in, 0, orig - in->str);
p = in->str;
- while ((!g_ascii_isspace (*p) && *p != '>') && p - in->str < (gint)in->len) {
- p ++;
- len ++;
+ while ((!g_ascii_isspace (*p) && *p !=
+ '>') && p - in->str < (gint)in->len) {
+ p++;
+ len++;
}
g_string_truncate (in, len);
}
static gboolean
-rspamd_protocol_handle_url (struct rspamd_task *task, struct rspamd_http_message *msg)
+rspamd_protocol_handle_url (struct rspamd_task *task,
+ struct rspamd_http_message *msg)
{
- GList *cur;
- struct custom_command *cmd;
+ GList *cur;
+ struct custom_command *cmd;
const gchar *p;
if (msg->url == NULL || msg->url->len == 0) {
gboolean
rspamd_protocol_handle_headers (struct rspamd_task *task,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- gchar *headern, *err, *tmp;
- gboolean res = TRUE;
- struct rspamd_http_header *h;
+ gchar *headern, *err, *tmp;
+ gboolean res = TRUE;
+ struct rspamd_http_header *h;
- LL_FOREACH (msg->headers, h) {
+ LL_FOREACH (msg->headers, h)
+ {
headern = h->name->str;
switch (headern[0]) {
case 'D':
if (g_ascii_strcasecmp (headern, DELIVER_TO_HEADER) == 0) {
task->deliver_to = rspamd_protocol_escape_braces (h->value);
- debug_task ("read deliver-to header, value: %s", task->deliver_to);
+ debug_task ("read deliver-to header, value: %s",
+ task->deliver_to);
}
else {
debug_task ("wrong header: %s", headern);
case 'P':
if (g_ascii_strcasecmp (headern, PASS_HEADER) == 0) {
if (h->value->len == sizeof ("all") - 1 &&
- g_ascii_strcasecmp (h->value->str, "all") == 0) {
+ g_ascii_strcasecmp (h->value->str, "all") == 0) {
task->pass_all_filters = TRUE;
debug_task ("pass all filters");
}
}
if (!res && task->cfg->strict_protocol_headers) {
- msg_err ("deny processing of a request with incorrect or unknown headers");
+ msg_err (
+ "deny processing of a request with incorrect or unknown headers");
task->last_error = "invalid header";
task->error_code = 400;
return FALSE;
gboolean
rspamd_protocol_handle_request (struct rspamd_task *task,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
gboolean ret = TRUE;
static void
write_hashes_to_log (struct rspamd_task *task, GString *logbuf)
{
- GList *cur;
- struct mime_text_part *text_part;
-
+ GList *cur;
+ struct mime_text_part *text_part;
+
cur = task->text_parts;
while (cur) {
text_part = cur->data;
if (text_part->fuzzy) {
if (cur->next != NULL) {
- rspamd_printf_gstring (logbuf, " part: %Xd,", text_part->fuzzy->h);
+ rspamd_printf_gstring (logbuf,
+ " part: %Xd,",
+ text_part->fuzzy->h);
}
else {
- rspamd_printf_gstring (logbuf, " part: %Xd", text_part->fuzzy->h);
+ rspamd_printf_gstring (logbuf, " part: %Xd",
+ text_part->fuzzy->h);
}
}
cur = g_list_next (cur);
static gboolean
urls_protocol_cb (gpointer key, gpointer value, gpointer ud)
{
- struct tree_cb_data *cb = ud;
- struct uri *url = value;
- ucl_object_t *obj;
+ struct tree_cb_data *cb = ud;
+ struct uri *url = value;
+ ucl_object_t *obj;
obj = ucl_object_fromlstring (url->host, url->hostlen);
DL_APPEND (cb->top->value.av, obj);
if (cb->task->cfg->log_urls) {
- msg_info ("<%s> URL: %s - %s: %s", cb->task->message_id, cb->task->user ?
- cb->task->user : (cb->task->from ? cb->task->from : "unknown"),
- rspamd_inet_address_to_string (&cb->task->from_addr),
- struri (url));
+ msg_info ("<%s> URL: %s - %s: %s",
+ cb->task->message_id,
+ cb->task->user ?
+ cb->task->user : (cb->task->from ? cb->task->from : "unknown"),
+ rspamd_inet_address_to_string (&cb->task->from_addr),
+ struri (url));
}
return FALSE;
static ucl_object_t *
rspamd_urls_tree_ucl (GTree *input, struct rspamd_task *task)
{
- struct tree_cb_data cb;
- ucl_object_t *obj;
+ struct tree_cb_data cb;
+ ucl_object_t *obj;
obj = ucl_object_typed_new (UCL_ARRAY);
cb.top = obj;
static gboolean
emails_protocol_cb (gpointer key, gpointer value, gpointer ud)
{
- struct tree_cb_data *cb = ud;
- struct uri *url = value;
- ucl_object_t *obj;
+ struct tree_cb_data *cb = ud;
+ struct uri *url = value;
+ ucl_object_t *obj;
obj = ucl_object_fromlstring (url->user, url->userlen + url->hostlen + 1);
DL_APPEND (cb->top->value.av, obj);
static ucl_object_t *
rspamd_emails_tree_ucl (GTree *input, struct rspamd_task *task)
{
- struct tree_cb_data cb;
- ucl_object_t *obj;
+ struct tree_cb_data cb;
+ ucl_object_t *obj;
obj = ucl_object_typed_new (UCL_ARRAY);
cb.top = obj;
static const gchar *
make_rewritten_subject (struct metric *metric, struct rspamd_task *task)
{
- static gchar subj_buf[1024];
- gchar *p = subj_buf, *end, *c, *res;
- const gchar *s;
+ static gchar subj_buf[1024];
+ gchar *p = subj_buf, *end, *c, *res;
+ const gchar *s;
end = p + sizeof(subj_buf);
c = metric->subject;
c += 2;
}
else {
- *p = *c ++;
+ *p = *c++;
}
- p ++;
+ p++;
}
res = g_mime_utils_header_encode_text (subj_buf);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_free, res);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_free,
+ res);
return res;
}
static ucl_object_t *
rspamd_str_list_ucl (GList *str_list)
{
- ucl_object_t *top = NULL, *obj;
- GList *cur;
+ ucl_object_t *top = NULL, *obj;
+ GList *cur;
top = ucl_object_typed_new (UCL_ARRAY);
cur = str_list;
static ucl_object_t *
rspamd_metric_symbol_ucl (struct rspamd_task *task, struct metric *m,
- struct symbol *sym, GString *logbuf)
+ struct symbol *sym, GString *logbuf)
{
- ucl_object_t *obj = NULL;
- const gchar *description = NULL;
+ ucl_object_t *obj = NULL;
+ const gchar *description = NULL;
rspamd_printf_gstring (logbuf, "%s,", sym->name);
description = g_hash_table_lookup (m->descriptions, sym->name);
obj = ucl_object_typed_new (UCL_OBJECT);
- ucl_object_insert_key (obj, ucl_object_fromstring (sym->name), "name", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromdouble (sym->score), "score", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ sym->name), "name", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromdouble (
+ sym->score), "score", 0, false);
if (description) {
- ucl_object_insert_key (obj, ucl_object_fromstring (description), "description", 0, false);
+ ucl_object_insert_key (obj, ucl_object_fromstring (
+ description), "description", 0, false);
}
if (sym->options != NULL) {
- ucl_object_insert_key (obj, rspamd_str_list_ucl (sym->options), "options", 0, false);
+ ucl_object_insert_key (obj, rspamd_str_list_ucl (
+ sym->options), "options", 0, false);
}
return obj;
}
static ucl_object_t *
-rspamd_metric_result_ucl (struct rspamd_task *task, struct metric_result *mres, GString *logbuf)
+rspamd_metric_result_ucl (struct rspamd_task *task,
+ struct metric_result *mres,
+ GString *logbuf)
{
- GHashTableIter hiter;
- struct symbol *sym;
- struct metric *m;
- gboolean is_spam;
- enum rspamd_metric_action action = METRIC_ACTION_NOACTION;
- ucl_object_t *obj = NULL, *sobj;
- gdouble required_score;
- gpointer h, v;
- const gchar *subject;
- gchar action_char;
+ GHashTableIter hiter;
+ struct symbol *sym;
+ struct metric *m;
+ gboolean is_spam;
+ enum rspamd_metric_action action = METRIC_ACTION_NOACTION;
+ ucl_object_t *obj = NULL, *sobj;
+ gdouble required_score;
+ gpointer h, v;
+ const gchar *subject;
+ gchar action_char;
m = mres->metric;
action_char = 'F';
}
rspamd_printf_gstring (logbuf, "(%s: %c (%s): [%.2f/%.2f] [",
- m->name, action_char,
- str_action_metric (action),
- mres->score, required_score);
+ m->name, action_char,
+ str_action_metric (action),
+ mres->score, required_score);
obj = ucl_object_typed_new (UCL_OBJECT);
- ucl_object_insert_key (obj, ucl_object_frombool (is_spam),
- "is_spam", 0, false);
- ucl_object_insert_key (obj, ucl_object_frombool (task->is_skipped),
- "is_skipped", 0, false);
+ ucl_object_insert_key (obj, ucl_object_frombool (is_spam),
+ "is_spam", 0, false);
+ ucl_object_insert_key (obj, ucl_object_frombool (task->is_skipped),
+ "is_skipped", 0, false);
ucl_object_insert_key (obj, ucl_object_fromdouble (mres->score),
- "score", 0, false);
+ "score", 0, false);
ucl_object_insert_key (obj, ucl_object_fromdouble (required_score),
- "required_score", 0, false);
- ucl_object_insert_key (obj, ucl_object_fromstring (str_action_metric (action)),
- "action", 0, false);
+ "required_score", 0, false);
+ ucl_object_insert_key (obj,
+ ucl_object_fromstring (str_action_metric (action)),
+ "action", 0, false);
if (action == METRIC_ACTION_REWRITE_SUBJECT) {
subject = make_rewritten_subject (m, task);
ucl_object_insert_key (obj, ucl_object_fromstring (subject),
- "subject", 0, false);
+ "subject", 0, false);
}
/* Now handle symbols */
g_hash_table_iter_init (&hiter, mres->symbols);
/* Cut the trailing comma if needed */
if (logbuf->str[logbuf->len - 1] == ',') {
- logbuf->len --;
+ logbuf->len--;
}
#ifdef HAVE_CLOCK_GETTIME
rspamd_printf_gstring (logbuf, "]), len: %z, time: %s, dns req: %d,",
- task->msg->len, calculate_check_time (&task->tv, &task->ts,
- task->cfg->clock_res, &task->scan_milliseconds), task->dns_requests);
+ task->msg->len, calculate_check_time (&task->tv, &task->ts,
+ task->cfg->clock_res, &task->scan_milliseconds), task->dns_requests);
#else
rspamd_printf_gstring (logbuf, "]), len: %z, time: %s, dns req: %d,",
- task->msg->len,
- calculate_check_time (&task->tv, task->cfg->clock_res, &task->scan_milliseconds),
- task->dns_requests);
+ task->msg->len,
+ calculate_check_time (&task->tv, task->cfg->clock_res,
+ &task->scan_milliseconds),
+ task->dns_requests);
#endif
return obj;
}
static void
-rspamd_ucl_tolegacy_output (struct rspamd_task *task, ucl_object_t *top, GString *out)
+rspamd_ucl_tolegacy_output (struct rspamd_task *task,
+ ucl_object_t *top,
+ GString *out)
{
const ucl_object_t *metric, *score,
- *required_score, *is_spam, *elt;
+ *required_score, *is_spam, *elt;
ucl_object_iter_t iter = NULL;
metric = ucl_object_find_key (top, DEFAULT_METRIC);
score = ucl_object_find_key (metric, "score");
required_score = ucl_object_find_key (metric, "required_score");
is_spam = ucl_object_find_key (metric, "is_spam");
- g_string_append_printf (out, "Metric: default; %s; %.2f / %.2f / 0.0\r\n",
- ucl_object_toboolean (is_spam) ? "True" : "False",
- ucl_object_todouble (score),
- ucl_object_todouble (required_score));
+ g_string_append_printf (out,
+ "Metric: default; %s; %.2f / %.2f / 0.0\r\n",
+ ucl_object_toboolean (is_spam) ? "True" : "False",
+ ucl_object_todouble (score),
+ ucl_object_todouble (required_score));
elt = ucl_object_find_key (metric, "action");
if (elt != NULL) {
g_string_append_printf (out, "Action: %s\r\n",
const ucl_object_t *sym_score;
sym_score = ucl_object_find_key (elt, "score");
g_string_append_printf (out, "Symbol: %s(%.2f)\r\n",
- ucl_object_key (elt),
- ucl_object_todouble (sym_score));
+ ucl_object_key (elt),
+ ucl_object_todouble (sym_score));
}
}
elt = ucl_object_find_key (metric, "subject");
if (elt != NULL) {
g_string_append_printf (out, "Subject: %s\r\n",
- ucl_object_tostring (elt));
+ ucl_object_tostring (elt));
}
}
g_string_append_printf (out, "Message-ID: %s\r\n", task->message_id);
}
void
-rspamd_protocol_http_reply (struct rspamd_http_message *msg, struct rspamd_task *task)
+rspamd_protocol_http_reply (struct rspamd_http_message *msg,
+ struct rspamd_task *task)
{
- GString *logbuf;
- struct metric_result *metric_res;
- GHashTableIter hiter;
- gpointer h, v;
- ucl_object_t *top = NULL, *obj;
- gdouble required_score;
- gint action;
+ GString *logbuf;
+ struct metric_result *metric_res;
+ GHashTableIter hiter;
+ gpointer h, v;
+ ucl_object_t *top = NULL, *obj;
+ gdouble required_score;
+ gint action;
/* Output the first line - check status */
logbuf = g_string_sized_new (BUFSIZ);
- rspamd_printf_gstring (logbuf, "id: <%s>, qid: <%s>, ", task->message_id, task->queue_id);
+ rspamd_printf_gstring (logbuf,
+ "id: <%s>, qid: <%s>, ",
+ task->message_id,
+ task->queue_id);
if (task->user) {
rspamd_printf_gstring (logbuf, "user: %s, ", task->user);
}
if (task->messages != NULL) {
- ucl_object_insert_key (top, rspamd_str_list_ucl (task->messages), "messages", 0, false);
+ ucl_object_insert_key (top, rspamd_str_list_ucl (
+ task->messages), "messages", 0, false);
}
if (g_tree_nnodes (task->urls) > 0) {
- ucl_object_insert_key (top, rspamd_urls_tree_ucl (task->urls, task), "urls", 0, false);
+ ucl_object_insert_key (top, rspamd_urls_tree_ucl (task->urls,
+ task), "urls", 0, false);
}
if (g_tree_nnodes (task->emails) > 0) {
ucl_object_insert_key (top, rspamd_emails_tree_ucl (task->emails, task),
- "emails", 0, false);
+ "emails", 0, false);
}
-
+
ucl_object_insert_key (top, ucl_object_fromstring (task->message_id),
- "message-id", 0, false);
+ "message-id", 0, false);
write_hashes_to_log (task, logbuf);
if (!task->no_log) {
/* Update stat for default metric */
metric_res = g_hash_table_lookup (task->results, DEFAULT_METRIC);
if (metric_res != NULL) {
- required_score = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
+ required_score =
+ metric_res->metric->actions[METRIC_ACTION_REJECT].score;
action = check_metric_action (metric_res->score, required_score,
metric_res->metric);
if (action <= METRIC_ACTION_NOACTION) {
- task->worker->srv->stat->actions_stat[action] ++;
+ task->worker->srv->stat->actions_stat[action]++;
}
}
void
rspamd_protocol_write_reply (struct rspamd_task *task)
{
- struct rspamd_http_message *msg;
- const gchar *ctype = "application/json";
- ucl_object_t *top = NULL;
+ struct rspamd_http_message *msg;
+ const gchar *ctype = "application/json";
+ ucl_object_t *top = NULL;
msg = rspamd_http_new_message (HTTP_RESPONSE);
if (!task->is_json) {
msg->code = 500 + task->error_code % 100;
msg->status = g_string_new (task->last_error);
ucl_object_insert_key (top, ucl_object_fromstring (task->last_error),
- "error", 0, false);
+ "error", 0, false);
msg->body = g_string_sized_new (256);
rspamd_ucl_emit_gstring (top, UCL_EMIT_JSON_COMPACT, msg->body);
ucl_object_unref (top);
rspamd_http_connection_reset (task->http_conn);
rspamd_http_connection_write_message (task->http_conn, msg, NULL,
- ctype, task, task->sock, &task->tv, task->ev_base);
+ ctype, task, task->sock, &task->tv, task->ev_base);
}
void
register_protocol_command (const gchar *name, protocol_reply_func func)
{
- struct custom_command *cmd;
+ struct custom_command *cmd;
cmd = g_malloc (sizeof (struct custom_command));
cmd->name = name;
* @return
*/
gboolean rspamd_protocol_handle_headers (struct rspamd_task *task,
- struct rspamd_http_message *msg);
+ struct rspamd_http_message *msg);
/**
* Process HTTP request to the task structure
* @return
*/
gboolean rspamd_protocol_handle_request (struct rspamd_task *task,
- struct rspamd_http_message *msg);
+ struct rspamd_http_message *msg);
/**
* Write task results to http message
* @param task
*/
void rspamd_protocol_http_reply (struct rspamd_http_message *msg,
- struct rspamd_task *task);
+ struct rspamd_task *task);
/**
* Write reply for specified task command
static void rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data);
static void rspamd_proxy_client_handler (gint fd, gshort what, gpointer data);
-static inline GQuark
+static inline GQuark
proxy_error_quark (void)
{
return g_quark_from_static_string ("proxy-error");
static void
rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
{
- rspamd_proxy_t *proxy = data;
- gint r;
- GError *err = NULL;
+ rspamd_proxy_t *proxy = data;
+ gint r;
+ GError *err = NULL;
if (what == EV_READ) {
/* Got data from client */
proxy->read_len = r;
proxy->buf_offset = 0;
event_del (&proxy->backend_ev);
- event_set (&proxy->backend_ev, proxy->bfd, EV_WRITE, rspamd_proxy_backend_handler, proxy);
+ event_set (&proxy->backend_ev,
+ proxy->bfd,
+ EV_WRITE,
+ rspamd_proxy_backend_handler,
+ proxy);
event_add (&proxy->backend_ev, proxy->tv);
}
else {
/* Error case or zero reply */
if (r < 0) {
/* Error case */
- g_set_error (&err, proxy_error_quark(), r, "Client read error: %s", strerror (errno));
+ g_set_error (&err,
+ proxy_error_quark (), r, "Client read error: %s",
+ strerror (errno));
rspamd_proxy_close (proxy);
proxy->err_cb (err, proxy->user_data);
}
}
else if (what == EV_WRITE) {
/* Can write to client */
- r = write (proxy->cfd, proxy->buf + proxy->buf_offset, proxy->read_len - proxy->buf_offset);
+ r = write (proxy->cfd,
+ proxy->buf + proxy->buf_offset,
+ proxy->read_len - proxy->buf_offset);
if (r > 0) {
/* We wrote something */
- proxy->buf_offset +=r;
+ proxy->buf_offset += r;
if (proxy->buf_offset == proxy->read_len) {
/* We wrote everything */
event_del (&proxy->client_ev);
- event_set (&proxy->client_ev, proxy->cfd, EV_READ, rspamd_proxy_client_handler, proxy);
+ event_set (&proxy->client_ev,
+ proxy->cfd,
+ EV_READ,
+ rspamd_proxy_client_handler,
+ proxy);
event_add (&proxy->client_ev, proxy->tv);
event_del (&proxy->backend_ev);
- event_set (&proxy->backend_ev, proxy->bfd, EV_READ, rspamd_proxy_backend_handler, proxy);
+ event_set (&proxy->backend_ev,
+ proxy->bfd,
+ EV_READ,
+ rspamd_proxy_backend_handler,
+ proxy);
event_add (&proxy->backend_ev, proxy->tv);
}
else {
/* Error case or zero reply */
if (r < 0) {
/* Error case */
- g_set_error (&err, proxy_error_quark(), r, "Client write error: %s", strerror (errno));
+ g_set_error (&err,
+ proxy_error_quark (), r, "Client write error: %s",
+ strerror (errno));
rspamd_proxy_close (proxy);
proxy->err_cb (err, proxy->user_data);
}
}
else {
/* Got timeout */
- g_set_error (&err, proxy_error_quark(), ETIMEDOUT, "Client timeout");
+ g_set_error (&err, proxy_error_quark (), ETIMEDOUT, "Client timeout");
rspamd_proxy_close (proxy);
proxy->err_cb (err, proxy->user_data);
}
static void
rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
{
- rspamd_proxy_t *proxy = data;
- gint r;
- GError *err = NULL;
+ rspamd_proxy_t *proxy = data;
+ gint r;
+ GError *err = NULL;
if (what == EV_READ) {
/* Got data from backend */
proxy->read_len = r;
proxy->buf_offset = 0;
event_del (&proxy->client_ev);
- event_set (&proxy->client_ev, proxy->bfd, EV_WRITE, rspamd_proxy_client_handler, proxy);
+ event_set (&proxy->client_ev,
+ proxy->bfd,
+ EV_WRITE,
+ rspamd_proxy_client_handler,
+ proxy);
event_add (&proxy->client_ev, proxy->tv);
}
else {
/* Error case or zero reply */
if (r < 0) {
/* Error case */
- g_set_error (&err, proxy_error_quark(), r, "Backend read error: %s", strerror (errno));
+ g_set_error (&err,
+ proxy_error_quark (), r, "Backend read error: %s",
+ strerror (errno));
rspamd_proxy_close (proxy);
proxy->err_cb (err, proxy->user_data);
}
}
else if (what == EV_WRITE) {
/* Can write to backend */
- r = write (proxy->bfd, proxy->buf + proxy->buf_offset, proxy->read_len - proxy->buf_offset);
+ r = write (proxy->bfd,
+ proxy->buf + proxy->buf_offset,
+ proxy->read_len - proxy->buf_offset);
if (r > 0) {
/* We wrote something */
- proxy->buf_offset +=r;
+ proxy->buf_offset += r;
if (proxy->buf_offset == proxy->read_len) {
/* We wrote everything */
event_del (&proxy->backend_ev);
- event_set (&proxy->backend_ev, proxy->bfd, EV_READ, rspamd_proxy_backend_handler, proxy);
+ event_set (&proxy->backend_ev,
+ proxy->bfd,
+ EV_READ,
+ rspamd_proxy_backend_handler,
+ proxy);
event_add (&proxy->backend_ev, proxy->tv);
event_del (&proxy->client_ev);
- event_set (&proxy->client_ev, proxy->cfd, EV_READ, rspamd_proxy_client_handler, proxy);
+ event_set (&proxy->client_ev,
+ proxy->cfd,
+ EV_READ,
+ rspamd_proxy_client_handler,
+ proxy);
event_add (&proxy->client_ev, proxy->tv);
}
else {
/* Error case or zero reply */
if (r < 0) {
/* Error case */
- g_set_error (&err, proxy_error_quark(), r, "Backend write error: %s", strerror (errno));
+ g_set_error (&err,
+ proxy_error_quark (), r, "Backend write error: %s",
+ strerror (errno));
rspamd_proxy_close (proxy);
proxy->err_cb (err, proxy->user_data);
}
}
else {
/* Got timeout */
- g_set_error (&err, proxy_error_quark(), ETIMEDOUT, "Client timeout");
+ g_set_error (&err, proxy_error_quark (), ETIMEDOUT, "Client timeout");
rspamd_proxy_close (proxy);
proxy->err_cb (err, proxy->user_data);
}
* @param ud user data for callback
* @return new proxy object
*/
-rspamd_proxy_t*
-rspamd_create_proxy (gint cfd, gint bfd, rspamd_mempool_t *pool, struct event_base *base,
- gsize bufsize, struct timeval *tv, dispatcher_err_callback_t err_cb, gpointer ud)
+rspamd_proxy_t *
+rspamd_create_proxy (gint cfd,
+ gint bfd,
+ rspamd_mempool_t *pool,
+ struct event_base *base,
+ gsize bufsize,
+ struct timeval *tv,
+ dispatcher_err_callback_t err_cb,
+ gpointer ud)
{
- rspamd_proxy_t *new;
+ rspamd_proxy_t *new;
new = rspamd_mempool_alloc0 (pool, sizeof (rspamd_proxy_t));
new->tv = tv;
/* Set client's and backend's interfaces to read events */
- event_set (&new->client_ev, new->cfd, EV_READ, rspamd_proxy_client_handler, new);
+ event_set (&new->client_ev,
+ new->cfd,
+ EV_READ,
+ rspamd_proxy_client_handler,
+ new);
event_base_set (new->base, &new->client_ev);
event_add (&new->client_ev, new->tv);
- event_set (&new->backend_ev, new->bfd, EV_READ, rspamd_proxy_backend_handler, new);
+ event_set (&new->backend_ev,
+ new->bfd,
+ EV_READ,
+ rspamd_proxy_backend_handler,
+ new);
event_base_set (new->base, &new->backend_ev);
event_add (&new->backend_ev, new->tv);
#ifndef PROXY_H_
#define PROXY_H_
-#include "config.h"
#include "buffer.h"
+#include "config.h"
/**
* @file proxy.h
*/
typedef struct rspamd_proxy_s {
- struct event client_ev; /**< event for client's communication */
- struct event backend_ev; /**< event for backend communication */
- struct event_base *base; /**< base for event operations */
- rspamd_mempool_t *pool; /**< memory pool */
- dispatcher_err_callback_t err_cb; /**< error callback */
- struct event_base *ev_base; /**< event base */
- gint cfd; /**< client's socket */
- gint bfd; /**< backend's socket */
- guint8 *buf; /**< exchange buffer */
- gsize bufsize; /**< buffer size */
- gint read_len; /**< read length */
- gint buf_offset; /**< offset to write */
- gpointer user_data; /**< user's data for callbacks */
- struct timeval *tv; /**< timeout for communications */
- gboolean closed; /**< whether descriptors are closed */
+ struct event client_ev; /**< event for client's communication */
+ struct event backend_ev; /**< event for backend communication */
+ struct event_base *base; /**< base for event operations */
+ rspamd_mempool_t *pool; /**< memory pool */
+ dispatcher_err_callback_t err_cb; /**< error callback */
+ struct event_base *ev_base; /**< event base */
+ gint cfd; /**< client's socket */
+ gint bfd; /**< backend's socket */
+ guint8 *buf; /**< exchange buffer */
+ gsize bufsize; /**< buffer size */
+ gint read_len; /**< read length */
+ gint buf_offset; /**< offset to write */
+ gpointer user_data; /**< user's data for callbacks */
+ struct timeval *tv; /**< timeout for communications */
+ gboolean closed; /**< whether descriptors are closed */
} rspamd_proxy_t;
/**
* @param ud user data for callback
* @return new proxy object
*/
-rspamd_proxy_t* rspamd_create_proxy (gint cfd, gint bfd, rspamd_mempool_t *pool,
- struct event_base *base, gsize bufsize, struct timeval *tv,
- dispatcher_err_callback_t err_cb, gpointer ud);
+rspamd_proxy_t * rspamd_create_proxy (gint cfd,
+ gint bfd,
+ rspamd_mempool_t *pool,
+ struct event_base *base,
+ gsize bufsize,
+ struct timeval *tv,
+ dispatcher_err_callback_t err_cb,
+ gpointer ud);
void rspamd_proxy_close (rspamd_proxy_t *proxy);
* @param pool pool for shared memory
* @return new structure
*/
-struct roll_history*
+struct roll_history *
rspamd_roll_history_new (rspamd_mempool_t *pool)
{
- struct roll_history *new;
+ struct roll_history *new;
if (pool == NULL) {
return NULL;
static void
roll_history_symbols_callback (gpointer key, gpointer value, void *user_data)
{
- struct history_metric_callback_data *cb = user_data;
- struct symbol *s = value;
- guint wr;
+ struct history_metric_callback_data *cb = user_data;
+ struct symbol *s = value;
+ guint wr;
if (cb->remain > 0) {
wr = rspamd_snprintf (cb->pos, cb->remain, "%s, ", s->name);
* @param task task object
*/
void
-rspamd_roll_history_update (struct roll_history *history, struct rspamd_task *task)
+rspamd_roll_history_update (struct roll_history *history,
+ struct rspamd_task *task)
{
- gint row_num;
- struct roll_history_row *row;
- struct metric_result *metric_res;
- struct history_metric_callback_data cbdata;
+ gint row_num;
+ struct roll_history_row *row;
+ struct metric_result *metric_res;
+ struct history_metric_callback_data cbdata;
if (history->need_lock) {
/* Some process is getting history, so wait on a mutex */
/* Add information from task to roll history */
memcpy (&row->from_addr, &task->from_addr, sizeof (row->from_addr));
- memcpy (&row->tv, &task->tv, sizeof (row->tv));
+ memcpy (&row->tv, &task->tv, sizeof (row->tv));
/* Strings */
- rspamd_strlcpy (row->message_id, task->message_id, sizeof (row->message_id));
+ rspamd_strlcpy (row->message_id, task->message_id,
+ sizeof (row->message_id));
if (task->user) {
rspamd_strlcpy (row->user, task->user, sizeof (row->message_id));
}
}
/* Get default metric */
- metric_res = g_hash_table_lookup (task->results, DEFAULT_METRIC);
+ metric_res = g_hash_table_lookup (task->results, DEFAULT_METRIC);
if (metric_res == NULL) {
row->symbols[0] = '\0';
row->action = METRIC_ACTION_NOACTION;
}
else {
row->score = metric_res->score;
- row->required_score = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
+ row->required_score =
+ metric_res->metric->actions[METRIC_ACTION_REJECT].score;
row->action = check_metric_action (metric_res->score,
- metric_res->metric->actions[METRIC_ACTION_REJECT].score, metric_res->metric);
+ metric_res->metric->actions[METRIC_ACTION_REJECT].score,
+ metric_res->metric);
cbdata.pos = row->symbols;
cbdata.remain = sizeof (row->symbols);
- g_hash_table_foreach (metric_res->symbols, roll_history_symbols_callback, &cbdata);
+ g_hash_table_foreach (metric_res->symbols,
+ roll_history_symbols_callback,
+ &cbdata);
if (cbdata.remain > 0) {
/* Remove last whitespace and comma */
*cbdata.pos-- = '\0';
gboolean
rspamd_roll_history_load (struct roll_history *history, const gchar *filename)
{
- gint fd;
- struct stat st;
+ gint fd;
+ struct stat st;
if (stat (filename, &st) == -1) {
- msg_info ("cannot load history from %s: %s", filename, strerror (errno));
+ msg_info ("cannot load history from %s: %s", filename,
+ strerror (errno));
return FALSE;
}
}
if ((fd = open (filename, O_RDONLY)) == -1) {
- msg_info ("cannot load history from %s: %s", filename, strerror (errno));
+ msg_info ("cannot load history from %s: %s", filename,
+ strerror (errno));
return FALSE;
}
if (read (fd, history->rows, sizeof (history->rows)) == -1) {
close (fd);
- msg_info ("cannot read history from %s: %s", filename, strerror (errno));
+ msg_info ("cannot read history from %s: %s", filename,
+ strerror (errno));
return FALSE;
}
gboolean
rspamd_roll_history_save (struct roll_history *history, const gchar *filename)
{
- gint fd;
+ gint fd;
if ((fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, 00600)) == -1) {
msg_info ("cannot save history to %s: %s", filename, strerror (errno));
* @param pool pool for shared memory
* @return new structure
*/
-struct roll_history* rspamd_roll_history_new (rspamd_mempool_t *pool);
+struct roll_history * rspamd_roll_history_new (rspamd_mempool_t *pool);
/**
* Update roll history with data from task
* @param history roll history object
* @param task task object
*/
-void rspamd_roll_history_update (struct roll_history *history, struct rspamd_task *task);
+void rspamd_roll_history_update (struct roll_history *history,
+ struct rspamd_task *task);
/**
* Load previously saved history from file
* @param filename filename to load from
* @return TRUE if history has been loaded
*/
-gboolean rspamd_roll_history_load (struct roll_history *history, const gchar *filename);
+gboolean rspamd_roll_history_load (struct roll_history *history,
+ const gchar *filename);
/**
* Save history to file
* @param filename filename to load from
* @return TRUE if history has been saved
*/
-gboolean rspamd_roll_history_save (struct roll_history *history, const gchar *filename);
+gboolean rspamd_roll_history_save (struct roll_history *history,
+ const gchar *filename);
#endif /* ROLL_HISTORY_H_ */
#include "config.h"
#include "dns.h"
-#include "spf.h"
+#include "filter.h"
#include "main.h"
#include "message.h"
-#include "filter.h"
+#include "spf.h"
#define SPF_VER1_STR "v=spf1"
#define SPF_VER2_STR "spf2."
gboolean in_include;
};
-#define CHECK_REC(rec) \
-do { \
- if ((rec)->nested > SPF_MAX_NESTING || \
- (rec)->dns_requests > SPF_MAX_DNS_REQUESTS) { \
- msg_info ("<%s> spf recursion limit %d is reached, domain: %s", \
- (rec)->task->message_id, (rec)->dns_requests, \
- (rec)->sender_domain); \
- return FALSE; \
- } \
-} while (0) \
-
-static gboolean parse_spf_record (struct rspamd_task *task, struct spf_record *rec);
-static gboolean start_spf_parse (struct spf_record *rec, gchar *begin, guint ttl);
+#define CHECK_REC(rec) \
+ do { \
+ if ((rec)->nested > SPF_MAX_NESTING || \
+ (rec)->dns_requests > SPF_MAX_DNS_REQUESTS) { \
+ msg_info ("<%s> spf recursion limit %d is reached, domain: %s", \
+ (rec)->task->message_id, (rec)->dns_requests, \
+ (rec)->sender_domain); \
+ return FALSE; \
+ } \
+ } while (0) \
+
+static gboolean parse_spf_record (struct rspamd_task *task,
+ struct spf_record *rec);
+static gboolean start_spf_parse (struct spf_record *rec, gchar *begin,
+ guint ttl);
/* Determine spf mech */
static spf_mech_t
check_spf_mech (const gchar *elt, gboolean *need_shift)
{
g_assert (elt != NULL);
-
+
*need_shift = TRUE;
switch (*elt) {
- case '-':
- return SPF_FAIL;
- case '~':
- return SPF_SOFT_FAIL;
- case '+':
- return SPF_PASS;
- case '?':
- return SPF_NEUTRAL;
- default:
- *need_shift = FALSE;
- return SPF_PASS;
+ case '-':
+ return SPF_FAIL;
+ case '~':
+ return SPF_SOFT_FAIL;
+ case '+':
+ return SPF_PASS;
+ case '?':
+ return SPF_NEUTRAL;
+ default:
+ *need_shift = FALSE;
+ return SPF_PASS;
}
}
static void
dump_spf_record (GList *addrs)
{
- struct spf_addr *addr;
- GList *cur;
- gint r = 0;
- gchar logbuf[BUFSIZ], c;
+ struct spf_addr *addr;
+ GList *cur;
+ gint r = 0;
+ gchar logbuf[BUFSIZ], c;
#ifdef HAVE_INET_PTON
- gchar ipbuf[INET6_ADDRSTRLEN];
+ gchar ipbuf[INET6_ADDRSTRLEN];
#else
- struct in_addr ina;
+ struct in_addr ina;
#endif
cur = addrs;
}
#ifdef HAVE_INET_PTON
if (addr->data.normal.ipv6) {
- inet_ntop (AF_INET6, &addr->data.normal.d.in6, ipbuf, sizeof (ipbuf));
+ inet_ntop (AF_INET6, &addr->data.normal.d.in6, ipbuf,
+ sizeof (ipbuf));
}
else {
- inet_ntop (AF_INET, &addr->data.normal.d.in4, ipbuf, sizeof (ipbuf));
+ inet_ntop (AF_INET, &addr->data.normal.d.in4, ipbuf,
+ sizeof (ipbuf));
}
- r += snprintf (logbuf + r, sizeof (logbuf) - r, "%c%s/%d; ", c, ipbuf, addr->data.normal.mask);
+ r += snprintf (logbuf + r,
+ sizeof (logbuf) - r,
+ "%c%s/%d; ",
+ c,
+ ipbuf,
+ addr->data.normal.mask);
#else
ina.s_addr = addr->data.normal.d.in4.s_addr;
- r += snprintf (logbuf + r, sizeof (logbuf) - r, "%c%s/%d; ", c, inet_ntoa (ina), addr->data.normal.mask);
+ r += snprintf (logbuf + r,
+ sizeof (logbuf) - r,
+ "%c%s/%d; ",
+ c,
+ inet_ntoa (ina),
+ addr->data.normal.mask);
#endif
}
else {
- r += snprintf (logbuf + r, sizeof (logbuf) - r, "%s; ", addr->spf_string);
+ r += snprintf (logbuf + r,
+ sizeof (logbuf) - r,
+ "%s; ",
+ addr->spf_string);
dump_spf_record (addr->data.list);
}
cur = g_list_next (cur);
static GList *
spf_addr_find (GList *addrs, gpointer to_find)
{
- struct spf_addr *addr;
- GList *cur, *res = NULL;
+ struct spf_addr *addr;
+ GList *cur, *res = NULL;
cur = addrs;
while (cur) {
static void
spf_record_destructor (gpointer r)
{
- struct spf_record *rec = r;
- GList *cur;
- struct spf_addr *addr;
+ struct spf_record *rec = r;
+ GList *cur;
+ struct spf_addr *addr;
if (rec->addrs) {
cur = rec->addrs;
}
static gboolean
-parse_spf_ipmask (const gchar *begin, struct spf_addr *addr, struct spf_record *rec)
+parse_spf_ipmask (const gchar *begin,
+ struct spf_addr *addr,
+ struct spf_record *rec)
{
- const gchar *pos;
- gchar mask_buf[5] = {'\0'}, *p;
- gint state = 0, dots = 0;
+ const gchar *pos;
+ gchar mask_buf[5] = {'\0'}, *p;
+ gint state = 0, dots = 0;
#ifdef HAVE_INET_PTON
- gchar ip_buf[INET6_ADDRSTRLEN];
+ gchar ip_buf[INET6_ADDRSTRLEN];
#else
- gchar ip_buf[INET_ADDRSTRLEN];
+ gchar ip_buf[INET_ADDRSTRLEN];
#endif
-
- bzero (ip_buf, sizeof (ip_buf));
+
+ bzero (ip_buf, sizeof (ip_buf));
bzero (mask_buf, sizeof (mask_buf));
pos = begin;
p = ip_buf;
while (*pos) {
switch (state) {
- case 0:
- /* Require ':' */
- if (*pos != ':') {
- msg_info ("<%s>: spf error for domain %s: semicolon missing",
- rec->task->message_id, rec->sender_domain);
- return FALSE;
- }
- state = 1;
- pos ++;
- p = ip_buf;
- dots = 0;
- break;
- case 1:
+ case 0:
+ /* Require ':' */
+ if (*pos != ':') {
+ msg_info ("<%s>: spf error for domain %s: semicolon missing",
+ rec->task->message_id, rec->sender_domain);
+ return FALSE;
+ }
+ state = 1;
+ pos++;
+ p = ip_buf;
+ dots = 0;
+ break;
+ case 1:
#ifdef HAVE_INET_PTON
- if (p - ip_buf >= (gint)sizeof (ip_buf)) {
- return FALSE;
- }
- if (g_ascii_isxdigit (*pos)) {
- *p ++ = *pos ++;
- }
- else if (*pos == '.' || *pos == ':') {
- *p ++ = *pos ++;
- dots ++;
- }
+ if (p - ip_buf >= (gint)sizeof (ip_buf)) {
+ return FALSE;
+ }
+ if (g_ascii_isxdigit (*pos)) {
+ *p++ = *pos++;
+ }
+ else if (*pos == '.' || *pos == ':') {
+ *p++ = *pos++;
+ dots++;
+ }
#else
- /* Begin parse ip */
- if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
- return FALSE;
- }
- if (g_ascii_isdigit (*pos)) {
- *p ++ = *pos ++;
- }
- else if (*pos == '.') {
- *p ++ = *pos ++;
- dots ++;
- }
+ /* Begin parse ip */
+ if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
+ return FALSE;
+ }
+ if (g_ascii_isdigit (*pos)) {
+ *p++ = *pos++;
+ }
+ else if (*pos == '.') {
+ *p++ = *pos++;
+ dots++;
+ }
#endif
- else if (*pos == '/') {
- pos ++;
- p = mask_buf;
- state = 2;
- }
- else {
- /* Invalid character */
- msg_info ("<%s>: spf error for domain %s: invalid ip address",
- rec->task->message_id, rec->sender_domain);
- return FALSE;
- }
- break;
- case 2:
- /* Parse mask */
- if (p - mask_buf >= (gint)sizeof (mask_buf)) {
- msg_info ("<%s>: spf error for domain %s: too long mask",
- rec->task->message_id, rec->sender_domain);
- return FALSE;
- }
- if (g_ascii_isdigit (*pos)) {
- *p ++ = *pos ++;
- }
- else {
- return FALSE;
- }
- break;
+ else if (*pos == '/') {
+ pos++;
+ p = mask_buf;
+ state = 2;
+ }
+ else {
+ /* Invalid character */
+ msg_info ("<%s>: spf error for domain %s: invalid ip address",
+ rec->task->message_id, rec->sender_domain);
+ return FALSE;
+ }
+ break;
+ case 2:
+ /* Parse mask */
+ if (p - mask_buf >= (gint)sizeof (mask_buf)) {
+ msg_info ("<%s>: spf error for domain %s: too long mask",
+ rec->task->message_id, rec->sender_domain);
+ return FALSE;
+ }
+ if (g_ascii_isdigit (*pos)) {
+ *p++ = *pos++;
+ }
+ else {
+ return FALSE;
+ }
+ break;
}
}
}
else {
msg_info ("<%s>: spf error for domain %s: invalid ip address",
- rec->task->message_id, rec->sender_domain);
+ rec->task->message_id, rec->sender_domain);
return FALSE;
}
}
if (!addr->data.normal.ipv6) {
addr->data.normal.mask = strtoul (mask_buf, NULL, 10);
if (addr->data.normal.mask > 32) {
- msg_info ("<%s>: spf error for domain %s: bad ipmask value: '%s'",
- rec->task->message_id, rec->sender_domain, begin);
+ msg_info (
+ "<%s>: spf error for domain %s: bad ipmask value: '%s'",
+ rec->task->message_id,
+ rec->sender_domain,
+ begin);
return FALSE;
}
}
else {
addr->data.normal.mask = strtoul (mask_buf, NULL, 10);
if (addr->data.normal.mask > 128) {
- msg_info ("<%s>: spf error for domain %s: bad ipmask value: '%s'",
- rec->task->message_id, rec->sender_domain, begin);
+ msg_info (
+ "<%s>: spf error for domain %s: bad ipmask value: '%s'",
+ rec->task->message_id,
+ rec->sender_domain,
+ begin);
return FALSE;
}
}
}
static gchar *
-parse_spf_hostmask (struct rspamd_task *task, const gchar *begin, struct spf_addr *addr, struct spf_record *rec)
+parse_spf_hostmask (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_addr *addr,
+ struct spf_record *rec)
{
- gchar *host = NULL, *p, mask_buf[3];
- gint hostlen;
+ gchar *host = NULL, *p, mask_buf[3];
+ gint hostlen;
bzero (mask_buf, sizeof (mask_buf));
if (*begin == '\0' || *begin == '/') {
addr->data.normal.mask = strtoul (mask_buf, NULL, 10);
if (addr->data.normal.mask > 32) {
msg_info ("<%s>: spf error for domain %s: too long mask",
- rec->task->message_id, rec->sender_domain);
+ rec->task->message_id, rec->sender_domain);
return FALSE;
}
if (host == NULL) {
static void
spf_record_process_addr (struct rdns_reply_entry *elt,
- struct spf_dns_cb *cb, struct rspamd_task *task)
+ struct spf_dns_cb *cb, struct rspamd_task *task)
{
struct spf_addr *addr = cb->addr, *new_addr;
GList *tmp = NULL;
memcpy (new_addr, addr, sizeof (struct spf_addr));
new_addr->data.normal.d.in4.s_addr = elt->content.a.addr.s_addr;
new_addr->data.normal.parsed = TRUE;
- cb->rec->addrs = g_list_insert_before (cb->rec->addrs, tmp, new_addr);
+ cb->rec->addrs = g_list_insert_before (cb->rec->addrs,
+ tmp,
+ new_addr);
}
else {
msg_info ("<%s>: spf error for domain %s: addresses mismatch",
- task->message_id, cb->rec->sender_domain);
+ task->message_id, cb->rec->sender_domain);
}
}
else if (elt->type == RDNS_REQUEST_AAAA) {
if (!addr->data.normal.parsed) {
memcpy (&addr->data.normal.d.in6,
- &elt->content.aaa.addr, sizeof (struct in6_addr));
+ &elt->content.aaa.addr, sizeof (struct in6_addr));
addr->data.normal.mask = 32;
addr->data.normal.parsed = TRUE;
addr->data.normal.ipv6 = TRUE;
/* Insert one more address */
tmp = spf_addr_find (cb->rec->addrs, addr);
if (tmp) {
- new_addr = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_addr));
+ new_addr =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct spf_addr));
memcpy (new_addr, addr, sizeof (struct spf_addr));
memcpy (&new_addr->data.normal.d.in6,
- &elt->content.aaa.addr, sizeof (struct in6_addr));
+ &elt->content.aaa.addr, sizeof (struct in6_addr));
new_addr->data.normal.parsed = TRUE;
new_addr->data.normal.ipv6 = TRUE;
- cb->rec->addrs = g_list_insert_before (cb->rec->addrs, tmp, new_addr);
+ cb->rec->addrs = g_list_insert_before (cb->rec->addrs,
+ tmp,
+ new_addr);
}
else {
msg_info ("<%s>: spf error for domain %s: addresses mismatch",
- task->message_id, cb->rec->sender_domain);
+ task->message_id, cb->rec->sender_domain);
}
}
}
static void
spf_record_dns_callback (struct rdns_reply *reply, gpointer arg)
{
- struct spf_dns_cb *cb = arg;
- gchar *begin;
- struct rdns_reply_entry *elt_data;
- GList *tmp = NULL;
- struct rspamd_task *task;
+ struct spf_dns_cb *cb = arg;
+ gchar *begin;
+ struct rdns_reply_entry *elt_data;
+ GList *tmp = NULL;
+ struct rspamd_task *task;
task = cb->rec->task;
- cb->rec->requests_inflight --;
+ cb->rec->requests_inflight--;
if (reply->code == RDNS_RC_NOERROR) {
/* Add all logic for all DNS states here */
- LL_FOREACH (reply->entries, elt_data) {
+ LL_FOREACH (reply->entries, elt_data)
+ {
switch (cb->cur_action) {
case SPF_RESOLVE_MX:
if (elt_data->type == RDNS_REQUEST_MX) {
/* Now resolve A record for this MX */
- if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
- elt_data->content.mx.name)) {
- task->dns_requests ++;
- cb->rec->requests_inflight ++;
+ if (make_dns_request (task->resolver, task->s,
+ task->task_pool,
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
+ elt_data->content.mx.name)) {
+ task->dns_requests++;
+ cb->rec->requests_inflight++;
}
- if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
- elt_data->content.mx.name)) {
- task->dns_requests ++;
- cb->rec->requests_inflight ++;
+ if (make_dns_request (task->resolver, task->s,
+ task->task_pool,
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
+ elt_data->content.mx.name)) {
+ task->dns_requests++;
+ cb->rec->requests_inflight++;
}
}
else {
break;
case SPF_RESOLVE_PTR:
if (elt_data->type == RDNS_REQUEST_PTR) {
- if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
- elt_data->content.ptr.name)) {
- task->dns_requests ++;
- cb->rec->requests_inflight ++;
+ if (make_dns_request (task->resolver, task->s,
+ task->task_pool,
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
+ elt_data->content.ptr.name)) {
+ task->dns_requests++;
+ cb->rec->requests_inflight++;
}
- if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
- elt_data->content.ptr.name)) {
- task->dns_requests ++;
- cb->rec->requests_inflight ++;
+ if (make_dns_request (task->resolver, task->s,
+ task->task_pool,
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
+ elt_data->content.ptr.name)) {
+ task->dns_requests++;
+ cb->rec->requests_inflight++;
}
}
else {
case SPF_RESOLVE_EXP:
break;
case SPF_RESOLVE_EXISTS:
- if (elt_data->type == RDNS_REQUEST_A || elt_data->type == RDNS_REQUEST_AAAA) {
+ if (elt_data->type == RDNS_REQUEST_A || elt_data->type ==
+ RDNS_REQUEST_AAAA) {
/* If specified address resolves, we can accept connection from every IP */
cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
cb->addr->data.normal.mask = 0;
}
else if (reply->code == RDNS_RC_NXDOMAIN) {
switch (cb->cur_action) {
- case SPF_RESOLVE_MX:
- if (rdns_request_has_type (reply->request, RDNS_REQUEST_MX)) {
- msg_info ("<%s>: spf error for domain %s: cannot find MX record for %s",
- task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
- cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
- cb->addr->data.normal.mask = 32;
- }
- else {
- msg_info ("<%s>: spf error for domain %s: cannot resolve MX record for %s",
- task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
- cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
- cb->addr->data.normal.mask = 32;
- }
- break;
- case SPF_RESOLVE_A:
- if (rdns_request_has_type (reply->request, RDNS_REQUEST_A)) {
- cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
- cb->addr->data.normal.mask = 32;
- }
- break;
+ case SPF_RESOLVE_MX:
+ if (rdns_request_has_type (reply->request, RDNS_REQUEST_MX)) {
+ msg_info (
+ "<%s>: spf error for domain %s: cannot find MX record for %s",
+ task->message_id,
+ cb->rec->sender_domain,
+ cb->rec->cur_domain);
+ cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+ cb->addr->data.normal.mask = 32;
+ }
+ else {
+ msg_info (
+ "<%s>: spf error for domain %s: cannot resolve MX record for %s",
+ task->message_id,
+ cb->rec->sender_domain,
+ cb->rec->cur_domain);
+ cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+ cb->addr->data.normal.mask = 32;
+ }
+ break;
+ case SPF_RESOLVE_A:
+ if (rdns_request_has_type (reply->request, RDNS_REQUEST_A)) {
+ cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+ cb->addr->data.normal.mask = 32;
+ }
+ break;
#ifdef HAVE_INET_PTON
- case SPF_RESOLVE_AAA:
- if (rdns_request_has_type (reply->request, RDNS_REQUEST_AAAA)) {
- memset (&cb->addr->data.normal.d.in6, 0xff, sizeof (struct in6_addr));
- cb->addr->data.normal.mask = 32;
- }
- break;
+ case SPF_RESOLVE_AAA:
+ if (rdns_request_has_type (reply->request, RDNS_REQUEST_AAAA)) {
+ memset (&cb->addr->data.normal.d.in6, 0xff,
+ sizeof (struct in6_addr));
+ cb->addr->data.normal.mask = 32;
+ }
+ break;
#endif
- case SPF_RESOLVE_PTR:
- break;
- case SPF_RESOLVE_REDIRECT:
- msg_info ("<%s>: spf error for domain %s: cannot resolve TXT record for %s",
- task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
- break;
- case SPF_RESOLVE_INCLUDE:
- msg_info ("<%s>: spf error for domain %s: cannot resolve TXT record for %s",
- task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
- break;
- case SPF_RESOLVE_EXP:
- break;
- case SPF_RESOLVE_EXISTS:
- cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
- cb->addr->data.normal.mask = 32;
- break;
+ case SPF_RESOLVE_PTR:
+ break;
+ case SPF_RESOLVE_REDIRECT:
+ msg_info (
+ "<%s>: spf error for domain %s: cannot resolve TXT record for %s",
+ task->message_id,
+ cb->rec->sender_domain,
+ cb->rec->cur_domain);
+ break;
+ case SPF_RESOLVE_INCLUDE:
+ msg_info (
+ "<%s>: spf error for domain %s: cannot resolve TXT record for %s",
+ task->message_id,
+ cb->rec->sender_domain,
+ cb->rec->cur_domain);
+ break;
+ case SPF_RESOLVE_EXP:
+ break;
+ case SPF_RESOLVE_EXISTS:
+ cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+ cb->addr->data.normal.mask = 32;
+ break;
}
}
}
static gboolean
-parse_spf_a (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_a (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- gchar *host = NULL;
-
+ gchar *host = NULL;
+
CHECK_REC (rec);
-
+
/*
* a
* a/<prefix-length>
addr->data.normal.mask = 32;
}
else if (*begin == ':') {
- begin ++;
+ begin++;
}
else if (*begin != '/') {
/* Invalid A record */
return FALSE;
}
-
+
if (host == NULL) {
host = parse_spf_hostmask (task, begin, addr, rec);
}
-
+
if (host == NULL) {
return FALSE;
}
- rec->dns_requests ++;
+ rec->dns_requests++;
cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
cb->rec = rec;
cb->addr = addr;
cb->cur_action = SPF_RESOLVE_A;
cb->in_include = rec->in_include;
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
return TRUE;
}
}
static gboolean
-parse_spf_ptr (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_ptr (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- gchar *host, *ptr;
+ gchar *host, *ptr;
CHECK_REC (rec);
return FALSE;
}
if (*begin == ':') {
- begin ++;
+ begin++;
host = rspamd_mempool_strdup (task->task_pool, begin);
}
else if (*begin == '\0') {
return FALSE;
}
- rec->dns_requests ++;
+ rec->dns_requests++;
cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
cb->rec = rec;
cb->addr = addr;
cb->cur_action = SPF_RESOLVE_PTR;
cb->in_include = rec->in_include;
cb->ptr_host = host;
- ptr = rdns_generate_ptr_from_str (rspamd_inet_address_to_string (&task->from_addr));
+ ptr =
+ rdns_generate_ptr_from_str (rspamd_inet_address_to_string (
+ &task->from_addr));
if (ptr == NULL) {
return FALSE;
}
rspamd_mempool_add_destructor (task->task_pool, free, ptr);
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_PTR, ptr)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_PTR, ptr)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
return TRUE;
}
}
static gboolean
-parse_spf_mx (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_mx (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- gchar *host;
-
+ gchar *host;
+
CHECK_REC (rec);
-
+
if (begin == NULL) {
return FALSE;
}
if (*begin == ':') {
- begin ++;
+ begin++;
}
-
+
host = parse_spf_hostmask (task, begin, addr, rec);
-
+
if (host == NULL) {
return FALSE;
}
- rec->dns_requests ++;
+ rec->dns_requests++;
cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
cb->rec = rec;
cb->addr = addr;
cb->cur_action = SPF_RESOLVE_MX;
cb->in_include = rec->in_include;
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_MX, host)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
-
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_MX, host)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
+
return TRUE;
}
}
static gboolean
-parse_spf_all (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_all (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
/* All is 0/0 */
memset (&addr->data.normal.d, 0, sizeof (addr->data.normal.d));
}
static gboolean
-parse_spf_ip4 (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_ip4 (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
/* ip4:addr[/mask] */
#ifdef HAVE_INET_PTON
static gboolean
-parse_spf_ip6 (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_ip6 (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
/* ip6:addr[/mask] */
#endif
static gboolean
-parse_spf_include (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_include (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- gchar *domain;
+ gchar *domain;
CHECK_REC (rec);
if (begin == NULL || *begin != ':') {
return FALSE;
}
- begin ++;
- rec->dns_requests ++;
+ begin++;
+ rec->dns_requests++;
cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
cb->rec = rec;
addr->data.list = NULL;
domain = rspamd_mempool_strdup (task->task_pool, begin);
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
return TRUE;
}
}
static gboolean
-parse_spf_exp (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_exp (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
CHECK_REC (rec);
}
static gboolean
-parse_spf_redirect (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_redirect (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- gchar *domain;
+ gchar *domain;
CHECK_REC (rec);
if (begin == NULL || *begin != '=') {
return FALSE;
}
- begin ++;
- rec->dns_requests ++;
+ begin++;
+ rec->dns_requests++;
cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
cb->rec = rec;
cb->in_include = rec->in_include;
domain = rspamd_mempool_strdup (task->task_pool, begin);
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
-
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
+
return TRUE;
}
}
static gboolean
-parse_spf_exists (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_exists (struct rspamd_task *task,
+ const gchar *begin,
+ struct spf_record *rec,
+ struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- gchar *host;
+ gchar *host;
CHECK_REC (rec);
-
+
if (begin == NULL || *begin != ':') {
return FALSE;
}
- begin ++;
- rec->dns_requests ++;
+ begin++;
+ rec->dns_requests++;
addr->data.normal.mask = 32;
cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
host = rspamd_mempool_strdup (task->task_pool, begin);
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
-
+ spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
+
return TRUE;
}
static void
reverse_spf_ip (gchar *ip, gint len)
{
- gchar ipbuf[sizeof("255.255.255.255") - 1], *p, *c;
- gint t = 0, l = len;
+ gchar ipbuf[sizeof("255.255.255.255") - 1], *p, *c;
+ gint t = 0, l = len;
if (len > (gint)sizeof (ipbuf)) {
msg_info ("cannot reverse string of length %d", len);
}
p = ipbuf + len;
- c = ip;
- while (-- l) {
+ c = ip;
+ while (--l) {
if (*c == '.') {
memcpy (p, c - t, t);
*--p = '.';
- c ++;
+ c++;
t = 0;
continue;
}
- t ++;
- c ++;
- p --;
+ t++;
+ c++;
+ p--;
}
memcpy (p - 1, c - t, t + 1);
- memcpy (ip, ipbuf, len);
+ memcpy (ip, ipbuf, len);
}
static gchar *
-expand_spf_macro (struct rspamd_task *task, struct spf_record *rec, gchar *begin)
+expand_spf_macro (struct rspamd_task *task, struct spf_record *rec,
+ gchar *begin)
{
- gchar *p, *c, *new, *tmp;
- gint len = 0, slen = 0, state = 0;
+ gchar *p, *c, *new, *tmp;
+ gint len = 0, slen = 0, state = 0;
#ifdef HAVE_INET_PTON
- gchar ip_buf[INET6_ADDRSTRLEN];
+ gchar ip_buf[INET6_ADDRSTRLEN];
#endif
- gboolean need_expand = FALSE;
+ gboolean need_expand = FALSE;
p = begin;
/* Calculate length */
while (*p) {
switch (state) {
- case 0:
- /* Skip any character and wait for % in input */
- if (*p == '%') {
- state = 1;
- }
- else {
- len ++;
- }
+ case 0:
+ /* Skip any character and wait for % in input */
+ if (*p == '%') {
+ state = 1;
+ }
+ else {
+ len++;
+ }
- slen ++;
- p ++;
- break;
- case 1:
- /* We got % sign, so we should whether wait for { or for - or for _ or for % */
- if (*p == '%' || *p == '-') {
- /* Just a single % sign or space */
- len ++;
- }
- else if (*p == '_') {
- /* %20 */
- len += sizeof ("%20") - 1;
- }
- else if (*p == '{') {
- state = 2;
- }
- else {
- /* Something unknown */
- msg_info ("<%s>: spf error for domain %s: unknown spf element",
- task->message_id, rec->sender_domain);
- return begin;
- }
- p ++;
- slen ++;
- break;
- case 2:
- /* Read macro name */
- switch (g_ascii_tolower (*p)) {
- case 'i':
+ slen++;
+ p++;
+ break;
+ case 1:
+ /* We got % sign, so we should whether wait for { or for - or for _ or for % */
+ if (*p == '%' || *p == '-') {
+ /* Just a single % sign or space */
+ len++;
+ }
+ else if (*p == '_') {
+ /* %20 */
+ len += sizeof ("%20") - 1;
+ }
+ else if (*p == '{') {
+ state = 2;
+ }
+ else {
+ /* Something unknown */
+ msg_info ("<%s>: spf error for domain %s: unknown spf element",
+ task->message_id, rec->sender_domain);
+ return begin;
+ }
+ p++;
+ slen++;
+ break;
+ case 2:
+ /* Read macro name */
+ switch (g_ascii_tolower (*p)) {
+ case 'i':
#ifdef HAVE_INET_PTON
- len += sizeof (INET6_ADDRSTRLEN) - 1;
+ len += sizeof (INET6_ADDRSTRLEN) - 1;
#else
- len += sizeof (INET_ADDRSTRLEN) - 1;
+ len += sizeof (INET_ADDRSTRLEN) - 1;
#endif
- break;
- case 's':
- len += strlen (rec->sender);
- break;
- case 'l':
- len += strlen (rec->local_part);
- break;
- case 'o':
- len += strlen (rec->sender_domain);
- break;
- case 'd':
- len += strlen (rec->cur_domain);
- break;
- case 'v':
- len += sizeof ("in-addr") - 1;
- break;
- case 'h':
- if (task->helo) {
- len += strlen (task->helo);
- }
- break;
- default:
- msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
- task->message_id, rec->sender_domain, *p, begin);
- return begin;
- }
- p ++;
- slen ++;
- state = 3;
break;
- case 3:
- /* Read modifier */
- if (*p == '}') {
- state = 0;
- need_expand = TRUE;
+ case 's':
+ len += strlen (rec->sender);
+ break;
+ case 'l':
+ len += strlen (rec->local_part);
+ break;
+ case 'o':
+ len += strlen (rec->sender_domain);
+ break;
+ case 'd':
+ len += strlen (rec->cur_domain);
+ break;
+ case 'v':
+ len += sizeof ("in-addr") - 1;
+ break;
+ case 'h':
+ if (task->helo) {
+ len += strlen (task->helo);
}
- else if (*p != 'r' && !g_ascii_isdigit (*p)) {
- msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf modifier %c in %s",
- task->message_id, rec->sender_domain, *p, begin);
- return begin;
- }
- p ++;
- slen ++;
break;
+ default:
+ msg_info (
+ "<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
+ task->message_id,
+ rec->sender_domain,
+ *p,
+ begin);
+ return begin;
+ }
+ p++;
+ slen++;
+ state = 3;
+ break;
+ case 3:
+ /* Read modifier */
+ if (*p == '}') {
+ state = 0;
+ need_expand = TRUE;
+ }
+ else if (*p != 'r' && !g_ascii_isdigit (*p)) {
+ msg_info (
+ "<%s>: spf error for domain %s: unknown or unsupported spf modifier %c in %s",
+ task->message_id,
+ rec->sender_domain,
+ *p,
+ begin);
+ return begin;
+ }
+ p++;
+ slen++;
+ break;
}
}
/* No expansion needed */
return begin;
}
-
+
new = rspamd_mempool_alloc (task->task_pool, len + 1);
c = new;
while (*p) {
switch (state) {
- case 0:
- /* Skip any character and wait for % in input */
- if (*p == '%') {
- state = 1;
- }
- else {
- *c = *p;
- c ++;
- }
+ case 0:
+ /* Skip any character and wait for % in input */
+ if (*p == '%') {
+ state = 1;
+ }
+ else {
+ *c = *p;
+ c++;
+ }
- p ++;
- break;
- case 1:
- /* We got % sign, so we should whether wait for { or for - or for _ or for % */
- if (*p == '%') {
- /* Just a single % sign or space */
- *c++ = '%';
- }
- else if (*p == '-') {
- *c++ = ' ';
- }
- else if (*p == '_') {
- /* %20 */
- *c++ = '%';
- *c++ = '2';
- *c++ = '0';
- }
- else if (*p == '{') {
- state = 2;
- }
- else {
- /* Something unknown */
- msg_info ("<%s>: spf error for domain %s: unknown spf element",
- task->message_id, rec->sender_domain);
- return begin;
- }
- p ++;
- break;
- case 2:
- /* Read macro name */
- switch (g_ascii_tolower (*p)) {
- case 'i':
+ p++;
+ break;
+ case 1:
+ /* We got % sign, so we should whether wait for { or for - or for _ or for % */
+ if (*p == '%') {
+ /* Just a single % sign or space */
+ *c++ = '%';
+ }
+ else if (*p == '-') {
+ *c++ = ' ';
+ }
+ else if (*p == '_') {
+ /* %20 */
+ *c++ = '%';
+ *c++ = '2';
+ *c++ = '0';
+ }
+ else if (*p == '{') {
+ state = 2;
+ }
+ else {
+ /* Something unknown */
+ msg_info ("<%s>: spf error for domain %s: unknown spf element",
+ task->message_id, rec->sender_domain);
+ return begin;
+ }
+ p++;
+ break;
+ case 2:
+ /* Read macro name */
+ switch (g_ascii_tolower (*p)) {
+ case 'i':
#ifdef HAVE_INET_PTON
- len = rspamd_strlcpy (ip_buf,
- rspamd_inet_address_to_string (&task->from_addr),
- sizeof (ip_buf));
- memcpy (c, ip_buf, len);
+ len = rspamd_strlcpy (ip_buf,
+ rspamd_inet_address_to_string (&task->from_addr),
+ sizeof (ip_buf));
+ memcpy (c, ip_buf, len);
#else
- tmp = inet_ntoa (task->from_addr);
- len = strlen (tmp);
- memcpy (c, tmp, len);
+ tmp = inet_ntoa (task->from_addr);
+ len = strlen (tmp);
+ memcpy (c, tmp, len);
#endif
- c += len;
- break;
- case 's':
- len = strlen (rec->sender);
- memcpy (c, rec->sender, len);
- c += len;
- break;
- case 'l':
- len = strlen (rec->local_part);
- memcpy (c, rec->local_part, len);
- c += len;
- break;
- case 'o':
- len = strlen (rec->sender_domain);
- memcpy (c, rec->sender_domain, len);
- c += len;
- break;
- case 'd':
- len = strlen (rec->cur_domain);
- memcpy (c, rec->cur_domain, len);
- c += len;
- break;
- case 'v':
- len = sizeof ("in-addr") - 1;
- memcpy (c, "in-addr", len);
- c += len;
- break;
- case 'h':
- if (task->helo) {
- tmp = strchr (task->helo, '@');
- if (tmp) {
- len = strlen (tmp + 1);
- memcpy (c, tmp + 1, len);
- c += len;
- }
- }
- break;
- default:
- msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
- task->message_id, rec->sender_domain, *p, begin);
- return begin;
- }
- p ++;
- state = 3;
+ c += len;
break;
- case 3:
- /* Read modifier */
- if (*p == '}') {
- state = 0;
- }
- else if (*p == 'r' && len != 0) {
- reverse_spf_ip (c - len, len);
- len = 0;
- }
- else if (g_ascii_isdigit (*p)) {
- /*XXX: try to implement domain strimming */
+ case 's':
+ len = strlen (rec->sender);
+ memcpy (c, rec->sender, len);
+ c += len;
+ break;
+ case 'l':
+ len = strlen (rec->local_part);
+ memcpy (c, rec->local_part, len);
+ c += len;
+ break;
+ case 'o':
+ len = strlen (rec->sender_domain);
+ memcpy (c, rec->sender_domain, len);
+ c += len;
+ break;
+ case 'd':
+ len = strlen (rec->cur_domain);
+ memcpy (c, rec->cur_domain, len);
+ c += len;
+ break;
+ case 'v':
+ len = sizeof ("in-addr") - 1;
+ memcpy (c, "in-addr", len);
+ c += len;
+ break;
+ case 'h':
+ if (task->helo) {
+ tmp = strchr (task->helo, '@');
+ if (tmp) {
+ len = strlen (tmp + 1);
+ memcpy (c, tmp + 1, len);
+ c += len;
+ }
}
- else {
- msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
- task->message_id, rec->sender_domain, *p, begin);
- return begin;
- }
- p ++;
break;
+ default:
+ msg_info (
+ "<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
+ task->message_id,
+ rec->sender_domain,
+ *p,
+ begin);
+ return begin;
+ }
+ p++;
+ state = 3;
+ break;
+ case 3:
+ /* Read modifier */
+ if (*p == '}') {
+ state = 0;
+ }
+ else if (*p == 'r' && len != 0) {
+ reverse_spf_ip (c - len, len);
+ len = 0;
+ }
+ else if (g_ascii_isdigit (*p)) {
+ /*XXX: try to implement domain strimming */
+ }
+ else {
+ msg_info (
+ "<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
+ task->message_id,
+ rec->sender_domain,
+ *p,
+ begin);
+ return begin;
+ }
+ p++;
+ break;
}
}
/* Null terminate */
*c = '\0';
return new;
-
+
}
-#define NEW_ADDR(x) do { \
- (x) = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_addr)); \
- (x)->mech = check_spf_mech (rec->cur_elt, &need_shift); \
- (x)->spf_string = rspamd_mempool_strdup (task->task_pool, begin); \
- memset (&(x)->data.normal, 0, sizeof ((x)->data.normal)); \
- (x)->data.normal.mask = 32; \
- (x)->is_list = FALSE; \
+#define NEW_ADDR(x) do { \
+ (x) = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_addr)); \
+ (x)->mech = check_spf_mech (rec->cur_elt, &need_shift); \
+ (x)->spf_string = rspamd_mempool_strdup (task->task_pool, begin); \
+ memset (&(x)->data.normal, 0, sizeof ((x)->data.normal)); \
+ (x)->data.normal.mask = 32; \
+ (x)->is_list = FALSE; \
} while (0);
/* Read current element and try to parse record */
{
struct spf_addr *new = NULL;
gboolean need_shift, res = FALSE;
- gchar *begin;
-
+ gchar *begin;
+
rec->cur_elt = rec->elts[rec->elt_num];
if (rec->cur_elt == NULL) {
return FALSE;
}
else if (*rec->cur_elt == '\0') {
/* Silently skip empty elements */
- rec->elt_num ++;
+ rec->elt_num++;
return TRUE;
}
else {
begin = expand_spf_macro (task, rec, rec->cur_elt);
if (*begin == '?' || *begin == '+' || *begin == '-' || *begin == '~') {
- begin ++;
+ begin++;
}
/* Now check what we have */
switch (g_ascii_tolower (*begin)) {
- case 'a':
- /* all or a */
- if (g_ascii_strncasecmp (begin, SPF_ALL, sizeof (SPF_ALL) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_ALL) - 1;
- res = parse_spf_all (task, begin, rec, new);
- }
- else if (g_ascii_strncasecmp (begin, SPF_A, sizeof (SPF_A) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_A) - 1;
- res = parse_spf_a (task, begin, rec, new);
- }
- else {
- msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- }
- break;
- case 'i':
- /* include or ip4 */
- if (g_ascii_strncasecmp (begin, SPF_IP4, sizeof (SPF_IP4) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_IP4) - 1;
- res = parse_spf_ip4 (task, begin, rec, new);
- }
- else if (g_ascii_strncasecmp (begin, SPF_INCLUDE, sizeof (SPF_INCLUDE) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_INCLUDE) - 1;
- res = parse_spf_include (task, begin, rec, new);
- }
- else if (g_ascii_strncasecmp (begin, SPF_IP6, sizeof (SPF_IP6) - 1) == 0) {
+ case 'a':
+ /* all or a */
+ if (g_ascii_strncasecmp (begin, SPF_ALL,
+ sizeof (SPF_ALL) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_ALL) - 1;
+ res = parse_spf_all (task, begin, rec, new);
+ }
+ else if (g_ascii_strncasecmp (begin, SPF_A,
+ sizeof (SPF_A) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_A) - 1;
+ res = parse_spf_a (task, begin, rec, new);
+ }
+ else {
+ msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+ task->message_id, rec->sender_domain, begin);
+ }
+ break;
+ case 'i':
+ /* include or ip4 */
+ if (g_ascii_strncasecmp (begin, SPF_IP4,
+ sizeof (SPF_IP4) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_IP4) - 1;
+ res = parse_spf_ip4 (task, begin, rec, new);
+ }
+ else if (g_ascii_strncasecmp (begin, SPF_INCLUDE,
+ sizeof (SPF_INCLUDE) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_INCLUDE) - 1;
+ res = parse_spf_include (task, begin, rec, new);
+ }
+ else if (g_ascii_strncasecmp (begin, SPF_IP6, sizeof (SPF_IP6) -
+ 1) == 0) {
#ifdef HAVE_INET_PTON
- NEW_ADDR (new);
- begin += sizeof (SPF_IP6) - 1;
- res = parse_spf_ip6 (task, begin, rec, new);
+ NEW_ADDR (new);
+ begin += sizeof (SPF_IP6) - 1;
+ res = parse_spf_ip6 (task, begin, rec, new);
#else
- msg_info ("ignoring ip6 spf command as IPv6 is not supported: %s", begin);
- new = NULL;
- res = TRUE;
- begin += sizeof (SPF_IP6) - 1;
+ msg_info (
+ "ignoring ip6 spf command as IPv6 is not supported: %s",
+ begin);
+ new = NULL;
+ res = TRUE;
+ begin += sizeof (SPF_IP6) - 1;
#endif
- }
- else {
- msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- }
- break;
- case 'm':
- /* mx */
- if (g_ascii_strncasecmp (begin, SPF_MX, sizeof (SPF_MX) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_MX) - 1;
- res = parse_spf_mx (task, begin, rec, new);
- }
- else {
- msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- }
- break;
- case 'p':
- /* ptr */
- if (g_ascii_strncasecmp (begin, SPF_PTR, sizeof (SPF_PTR) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_PTR) - 1;
- res = parse_spf_ptr (task, begin, rec, new);
- }
- else {
- msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- }
- break;
- case 'e':
- /* exp or exists */
- if (g_ascii_strncasecmp (begin, SPF_EXP, sizeof (SPF_EXP) - 1) == 0) {
- begin += sizeof (SPF_EXP) - 1;
- res = parse_spf_exp (task, begin, rec, NULL);
- }
- else if (g_ascii_strncasecmp (begin, SPF_EXISTS, sizeof (SPF_EXISTS) - 1) == 0) {
- NEW_ADDR (new);
- begin += sizeof (SPF_EXISTS) - 1;
- res = parse_spf_exists (task, begin, rec, new);
- }
- else {
- msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- }
- break;
- case 'r':
- /* redirect */
- if (g_ascii_strncasecmp (begin, SPF_REDIRECT, sizeof (SPF_REDIRECT) - 1) == 0) {
- begin += sizeof (SPF_REDIRECT) - 1;
- res = parse_spf_redirect (task, begin, rec, NULL);
- }
- else {
- msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- }
- break;
- case 'v':
- if (g_ascii_strncasecmp (begin, "v=spf", sizeof ("v=spf") - 1) == 0) {
- /* Skip this element till the end of record */
- while (*begin && !g_ascii_isspace (*begin)) {
- begin ++;
- }
- }
- break;
- default:
+ }
+ else {
msg_info ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
- break;
+ task->message_id, rec->sender_domain, begin);
+ }
+ break;
+ case 'm':
+ /* mx */
+ if (g_ascii_strncasecmp (begin, SPF_MX, sizeof (SPF_MX) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_MX) - 1;
+ res = parse_spf_mx (task, begin, rec, new);
+ }
+ else {
+ msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+ task->message_id, rec->sender_domain, begin);
+ }
+ break;
+ case 'p':
+ /* ptr */
+ if (g_ascii_strncasecmp (begin, SPF_PTR,
+ sizeof (SPF_PTR) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_PTR) - 1;
+ res = parse_spf_ptr (task, begin, rec, new);
+ }
+ else {
+ msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+ task->message_id, rec->sender_domain, begin);
+ }
+ break;
+ case 'e':
+ /* exp or exists */
+ if (g_ascii_strncasecmp (begin, SPF_EXP,
+ sizeof (SPF_EXP) - 1) == 0) {
+ begin += sizeof (SPF_EXP) - 1;
+ res = parse_spf_exp (task, begin, rec, NULL);
+ }
+ else if (g_ascii_strncasecmp (begin, SPF_EXISTS,
+ sizeof (SPF_EXISTS) - 1) == 0) {
+ NEW_ADDR (new);
+ begin += sizeof (SPF_EXISTS) - 1;
+ res = parse_spf_exists (task, begin, rec, new);
+ }
+ else {
+ msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+ task->message_id, rec->sender_domain, begin);
+ }
+ break;
+ case 'r':
+ /* redirect */
+ if (g_ascii_strncasecmp (begin, SPF_REDIRECT,
+ sizeof (SPF_REDIRECT) - 1) == 0) {
+ begin += sizeof (SPF_REDIRECT) - 1;
+ res = parse_spf_redirect (task, begin, rec, NULL);
+ }
+ else {
+ msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+ task->message_id, rec->sender_domain, begin);
+ }
+ break;
+ case 'v':
+ if (g_ascii_strncasecmp (begin, "v=spf",
+ sizeof ("v=spf") - 1) == 0) {
+ /* Skip this element till the end of record */
+ while (*begin && !g_ascii_isspace (*begin)) {
+ begin++;
+ }
+ }
+ break;
+ default:
+ msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+ task->message_id, rec->sender_domain, begin);
+ break;
}
if (res) {
if (new != NULL) {
rec->addrs = g_list_prepend (rec->addrs, new);
}
- rec->elt_num ++;
+ rec->elt_num++;
}
}
static void
parse_spf_scopes (struct spf_record *rec, gchar **begin)
{
- for (;;) {
- if (g_ascii_strncasecmp (*begin, SPF_SCOPE_PRA, sizeof (SPF_SCOPE_PRA) - 1) == 0) {
+ for (;; ) {
+ if (g_ascii_strncasecmp (*begin, SPF_SCOPE_PRA, sizeof (SPF_SCOPE_PRA) -
+ 1) == 0) {
*begin += sizeof (SPF_SCOPE_PRA) - 1;
/* XXX: Implement actual PRA check */
/* extract_pra_info (rec); */
continue;
}
- else if (g_ascii_strncasecmp (*begin, SPF_SCOPE_MFROM, sizeof (SPF_SCOPE_MFROM) - 1) == 0) {
+ else if (g_ascii_strncasecmp (*begin, SPF_SCOPE_MFROM,
+ sizeof (SPF_SCOPE_MFROM) - 1) == 0) {
/* mfrom is standart spf1 check */
*begin += sizeof (SPF_SCOPE_MFROM) - 1;
continue;
else if (**begin != ',') {
break;
}
- (*begin) ++;
+ (*begin)++;
}
}
{
/* Skip spaces */
while (g_ascii_isspace (*begin)) {
- begin ++;
+ begin++;
}
- if (g_ascii_strncasecmp (begin, SPF_VER1_STR, sizeof (SPF_VER1_STR) - 1) == 0) {
+ if (g_ascii_strncasecmp (begin, SPF_VER1_STR,
+ sizeof (SPF_VER1_STR) - 1) == 0) {
begin += sizeof (SPF_VER1_STR) - 1;
while (g_ascii_isspace (*begin) && *begin) {
- begin ++;
+ begin++;
}
rec->elts = g_strsplit_set (begin, " ", 0);
rec->elt_num = 0;
if (rec->elts) {
- rspamd_mempool_add_destructor (rec->task->task_pool, (rspamd_mempool_destruct_t)g_strfreev, rec->elts);
+ rspamd_mempool_add_destructor (rec->task->task_pool,
+ (rspamd_mempool_destruct_t)g_strfreev, rec->elts);
rec->cur_elt = rec->elts[0];
- while (parse_spf_record (rec->task, rec));
+ while (parse_spf_record (rec->task, rec)) ;
if (ttl != 0) {
rec->ttl = ttl;
}
return TRUE;
}
}
- else if (g_ascii_strncasecmp (begin, SPF_VER2_STR, sizeof (SPF_VER2_STR) - 1) == 0) {
+ else if (g_ascii_strncasecmp (begin, SPF_VER2_STR, sizeof (SPF_VER2_STR) -
+ 1) == 0) {
/* Skip one number of record, so no we are here spf2.0/ */
begin += sizeof (SPF_VER2_STR);
if (*begin != '/') {
msg_info ("<%s>: spf error for domain %s: sender id is invalid",
- rec->task->message_id, rec->sender_domain);
+ rec->task->message_id, rec->sender_domain);
}
else {
- begin ++;
+ begin++;
parse_spf_scopes (rec, &begin);
}
/* Now common spf record */
while (g_ascii_isspace (*begin) && *begin) {
- begin ++;
+ begin++;
}
rec->elts = g_strsplit_set (begin, " ", 0);
rec->elt_num = 0;
if (rec->elts) {
- rspamd_mempool_add_destructor (rec->task->task_pool, (rspamd_mempool_destruct_t)g_strfreev, rec->elts);
+ rspamd_mempool_add_destructor (rec->task->task_pool,
+ (rspamd_mempool_destruct_t)g_strfreev, rec->elts);
rec->cur_elt = rec->elts[0];
- while (parse_spf_record (rec->task, rec));
+ while (parse_spf_record (rec->task, rec)) ;
if (ttl != 0) {
rec->ttl = ttl;
}
}
else {
msg_debug ("<%s>: spf error for domain %s: bad spf record version: %*s",
- rec->task->message_id, rec->sender_domain, sizeof (SPF_VER1_STR) - 1, begin);
+ rec->task->message_id,
+ rec->sender_domain,
+ sizeof (SPF_VER1_STR) - 1,
+ begin);
}
return FALSE;
}
struct spf_record *rec = arg;
struct rdns_reply_entry *elt;
- rec->requests_inflight --;
+ rec->requests_inflight--;
if (reply->code == RDNS_RC_NOERROR) {
- LL_FOREACH (reply->entries, elt) {
+ LL_FOREACH (reply->entries, elt)
+ {
if (start_spf_parse (rec, elt->content.txt.data, elt->ttl)) {
break;
}
gchar *
get_spf_domain (struct rspamd_task *task)
{
- gchar *domain, *res = NULL;
- GList *domains;
+ gchar *domain, *res = NULL;
+ GList *domains;
- if (task->from && (domain = strchr (task->from, '@')) != NULL && *domain == '@') {
+ if (task->from &&
+ (domain = strchr (task->from, '@')) != NULL && *domain == '@') {
res = rspamd_mempool_strdup (task->task_pool, domain + 1);
if ((domain = strchr (res, '>')) != NULL) {
*domain = '\0';
}
else {
/* Extract from header */
- domains = message_get_header (task->task_pool, task->message, "From", FALSE);
+ domains = message_get_header (task->task_pool,
+ task->message,
+ "From",
+ FALSE);
if (domains != NULL) {
res = rspamd_mempool_strdup (task->task_pool, domains->data);
gboolean
resolve_spf (struct rspamd_task *task, spf_cb_t callback)
{
- struct spf_record *rec;
- gchar *domain;
- GList *domains;
+ struct spf_record *rec;
+ gchar *domain;
+ GList *domains;
rec = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct spf_record));
rec->task = task;
rec->callback = callback;
/* Add destructor */
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)spf_record_destructor, rec);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)spf_record_destructor,
+ rec);
/* Extract from data */
- if (task->from && (domain = strchr (task->from, '@')) != NULL && *domain == '@') {
+ if (task->from &&
+ (domain = strchr (task->from, '@')) != NULL && *domain == '@') {
rec->sender = task->from;
rec->local_part = rspamd_mempool_strdup (task->task_pool, task->from);
*(rec->local_part + (domain - task->from)) = '\0';
if (*rec->local_part == '<') {
- memmove (rec->local_part, rec->local_part + 1, strlen (rec->local_part));
+ memmove (rec->local_part, rec->local_part + 1,
+ strlen (rec->local_part));
}
rec->cur_domain = rspamd_mempool_strdup (task->task_pool, domain + 1);
if ((domain = strchr (rec->cur_domain, '>')) != NULL) {
}
rec->sender_domain = rec->cur_domain;
- if (make_dns_request (task->resolver, task->s, task->task_pool, spf_dns_callback,
- (void *)rec, RDNS_REQUEST_TXT, rec->cur_domain)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
+ if (make_dns_request (task->resolver, task->s, task->task_pool,
+ spf_dns_callback,
+ (void *)rec, RDNS_REQUEST_TXT, rec->cur_domain)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
return TRUE;
}
}
else {
/* Extract from header */
- domains = message_get_header (task->task_pool, task->message, "From", FALSE);
+ domains = message_get_header (task->task_pool,
+ task->message,
+ "From",
+ FALSE);
if (domains != NULL) {
- rec->cur_domain = rspamd_mempool_strdup (task->task_pool, domains->data);
+ rec->cur_domain = rspamd_mempool_strdup (task->task_pool,
+ domains->data);
g_list_free (domains);
if ((domain = strrchr (rec->cur_domain, '@')) == NULL) {
return FALSE;
}
- rec->sender = rspamd_mempool_strdup (task->task_pool, rec->cur_domain);
+ rec->sender = rspamd_mempool_strdup (task->task_pool,
+ rec->cur_domain);
rec->local_part = rec->cur_domain;
*domain = '\0';
rec->cur_domain = domain + 1;
}
rec->sender_domain = rec->cur_domain;
if (make_dns_request (task->resolver, task->s, task->task_pool,
- spf_dns_callback, (void *)rec, RDNS_REQUEST_TXT, rec->cur_domain)) {
- task->dns_requests ++;
- rec->requests_inflight ++;
+ spf_dns_callback, (void *)rec, RDNS_REQUEST_TXT,
+ rec->cur_domain)) {
+ task->dns_requests++;
+ rec->requests_inflight++;
return TRUE;
}
}
return FALSE;
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
/*
* Get a domain for spf for specified task
*/
-gchar *get_spf_domain (struct rspamd_task *task);
+gchar * get_spf_domain (struct rspamd_task *task);
#endif
#include "config.h"
-#include "statfile.h"
#include "main.h"
+#include "statfile.h"
#define RSPAMD_STATFILE_VERSION {'1', '2'}
#define BACKUP_SUFFIX ".old"
/* Maximum number of statistics files */
#define STATFILES_MAX 255
static void statfile_pool_set_block_common (
- statfile_pool_t * pool, stat_file_t * file,
- guint32 h1, guint32 h2,
- time_t t, double value,
- gboolean from_now);
+ statfile_pool_t * pool, stat_file_t * file,
+ guint32 h1, guint32 h2,
+ time_t t, double value,
+ gboolean from_now);
static gint
cmpstatfile (const void *a, const void *b)
{
- const stat_file_t *s1 = a, *s2 = b;
+ const stat_file_t *s1 = a, *s2 = b;
return g_ascii_strcasecmp (s1->filename, s2->filename);
}
/* Convert statfile version 1.0 to statfile version 1.2, saving backup */
struct stat_file_header_10 {
- u_char magic[3]; /**< magic signature ('r' 's' 'd') */
- u_char version[2]; /**< version of statfile */
- u_char padding[3]; /**< padding */
- guint64 create_time; /**< create time (time_t->guint64) */
+ u_char magic[3]; /**< magic signature ('r' 's' 'd') */
+ u_char version[2]; /**< version of statfile */
+ u_char padding[3]; /**< padding */
+ guint64 create_time; /**< create time (time_t->guint64) */
};
static gboolean
convert_statfile_10 (stat_file_t * file)
{
- gchar *backup_name;
+ gchar *backup_name;
struct stat st;
- struct stat_file_header header = {
+ struct stat_file_header header = {
.magic = {'r', 's', 'd'},
.version = RSPAMD_STATFILE_VERSION,
.padding = {0, 0, 0},
/* Format backup name */
backup_name = g_strdup_printf ("%s.%s", file->filename, BACKUP_SUFFIX);
-
- msg_info ("convert old statfile %s to version %c.%c, backup in %s", file->filename,
- header.version[0], header.version[1], backup_name);
+
+ msg_info ("convert old statfile %s to version %c.%c, backup in %s",
+ file->filename,
+ header.version[0],
+ header.version[1],
+ backup_name);
if (stat (backup_name, &st) != -1) {
msg_info ("replace old %s", backup_name);
/* XXX: maybe race condition here */
unlock_file (file->fd, FALSE);
close (file->fd);
- if ((file->fd = open (file->filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
- msg_info ("cannot create file %s, error %d, %s", file->filename, errno, strerror (errno));
+ if ((file->fd =
+ open (file->filename, O_RDWR | O_TRUNC | O_CREAT,
+ S_IWUSR | S_IRUSR)) == -1) {
+ msg_info ("cannot create file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
lock_file (file->fd, FALSE);
/* Now make new header and copy it to new file */
if (write (file->fd, &header, sizeof (header)) == -1) {
- msg_info ("cannot write to file %s, error %d, %s", file->filename, errno, strerror (errno));
+ msg_info ("cannot write to file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
/* Now write old map to new file */
- if (write (file->fd, ((u_char *)file->map + sizeof (struct stat_file_header_10)),
- file->len - sizeof (struct stat_file_header_10)) == -1) {
- msg_info ("cannot write to file %s, error %d, %s", file->filename, errno, strerror (errno));
+ if (write (file->fd,
+ ((u_char *)file->map + sizeof (struct stat_file_header_10)),
+ file->len - sizeof (struct stat_file_header_10)) == -1) {
+ msg_info ("cannot write to file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
/* Unmap old memory and map new */
munmap (file->map, file->len);
- file->len = file->len + sizeof (struct stat_file_header) - sizeof (struct stat_file_header_10);
+ file->len = file->len + sizeof (struct stat_file_header) -
+ sizeof (struct stat_file_header_10);
#ifdef HAVE_MMAP_NOCORE
- if ((file->map = mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, file->fd, 0)) == MAP_FAILED) {
+ if ((file->map =
+ mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE,
+ file->fd, 0)) == MAP_FAILED) {
#else
- if ((file->map = mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd, 0)) == MAP_FAILED) {
+ if ((file->map =
+ mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd,
+ 0)) == MAP_FAILED) {
#endif
- msg_info ("cannot mmap file %s, error %d, %s", file->filename, errno, strerror (errno));
+ msg_info ("cannot mmap file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
static gint
statfile_pool_check (stat_file_t * file)
{
- struct stat_file *f;
- gchar *c;
- static gchar valid_version[] = RSPAMD_STATFILE_VERSION;
+ struct stat_file *f;
+ gchar *c;
+ static gchar valid_version[] = RSPAMD_STATFILE_VERSION;
if (!file || !file->map) {
}
if (file->len < sizeof (struct stat_file)) {
- msg_info ("file %s is too short to be stat file: %z", file->filename, file->len);
+ msg_info ("file %s is too short to be stat file: %z",
+ file->filename,
+ file->len);
return -1;
}
}
else if (memcmp (c, valid_version, sizeof (valid_version)) != 0) {
/* Unknown version */
- msg_info ("file %s has invalid version %c.%c", file->filename, '0' + *c, '0' + *(c + 1));
+ msg_info ("file %s has invalid version %c.%c",
+ file->filename,
+ '0' + *c,
+ '0' + *(c + 1));
return -1;
}
/* Check first section and set new offset */
file->cur_section.code = f->section.code;
file->cur_section.length = f->section.length;
- if (file->cur_section.length * sizeof (struct stat_file_block) > file->len) {
- msg_info ("file %s is truncated: %z, must be %z", file->filename, file->len, file->cur_section.length * sizeof (struct stat_file_block));
+ if (file->cur_section.length * sizeof (struct stat_file_block) >
+ file->len) {
+ msg_info ("file %s is truncated: %z, must be %z",
+ file->filename,
+ file->len,
+ file->cur_section.length * sizeof (struct stat_file_block));
return -1;
}
- file->seek_pos = sizeof (struct stat_file) - sizeof (struct stat_file_block);
+ file->seek_pos = sizeof (struct stat_file) -
+ sizeof (struct stat_file_block);
return 0;
}
-statfile_pool_t *
+statfile_pool_t *
statfile_pool_new (rspamd_mempool_t *pool, gboolean use_mlock)
{
- statfile_pool_t *new;
+ statfile_pool_t *new;
new = rspamd_mempool_alloc0 (pool, sizeof (statfile_pool_t));
new->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
- new->files = rspamd_mempool_alloc0 (new->pool, STATFILES_MAX * sizeof (stat_file_t));
+ new->files =
+ rspamd_mempool_alloc0 (new->pool, STATFILES_MAX * sizeof (stat_file_t));
new->lock = rspamd_mempool_get_mutex (new->pool);
new->mlock_ok = use_mlock;
}
static stat_file_t *
-statfile_pool_reindex (statfile_pool_t * pool, gchar *filename, size_t old_size, size_t size)
+statfile_pool_reindex (statfile_pool_t * pool,
+ gchar *filename,
+ size_t old_size,
+ size_t size)
{
- gchar *backup;
- gint fd;
- stat_file_t *new;
- u_char *map, *pos;
- struct stat_file_block *block;
- struct stat_file_header *header;
+ gchar *backup;
+ gint fd;
+ stat_file_t *new;
+ u_char *map, *pos;
+ struct stat_file_block *block;
+ struct stat_file_header *header;
if (size <
- sizeof (struct stat_file_header) + sizeof (struct stat_file_section) + sizeof (block)) {
- msg_err ("file %s is too small to carry any statistic: %z", filename, size);
+ sizeof (struct stat_file_header) + sizeof (struct stat_file_section) +
+ sizeof (block)) {
+ msg_err ("file %s is too small to carry any statistic: %z",
+ filename,
+ size);
return NULL;
}
backup = g_strconcat (filename, ".old", NULL);
if (rename (filename, backup) == -1) {
- msg_err ("cannot rename %s to %s: %s", filename, backup, strerror (errno));
+ msg_err ("cannot rename %s to %s: %s", filename, backup, strerror (
+ errno));
g_free (backup);
rspamd_mempool_unlock_mutex (pool->lock);
return NULL;
}
/* Now start reading blocks from old statfile */
- if ((map = mmap (NULL, old_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((map =
+ mmap (NULL, old_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
msg_err ("cannot mmap file: %s", strerror (errno));
close (fd);
g_free (backup);
while (old_size - (pos - map) >= sizeof (struct stat_file_block)) {
block = (struct stat_file_block *)pos;
if (block->hash1 != 0 && block->value != 0) {
- statfile_pool_set_block_common (pool, new, block->hash1, block->hash2, 0, block->value, FALSE);
+ statfile_pool_set_block_common (pool,
+ new,
+ block->hash1,
+ block->hash2,
+ 0,
+ block->value,
+ FALSE);
}
pos += sizeof (block);
}
header = (struct stat_file_header *)map;
statfile_set_revision (new, header->revision, header->rev_time);
-
+
munmap (map, old_size);
close (fd);
unlink (backup);
static void
statfile_preload (stat_file_t *file)
{
- guint8 *pos, *end;
- volatile guint8 t;
- gsize size;
+ guint8 *pos, *end;
+ volatile guint8 t;
+ gsize size;
pos = (guint8 *)file->map;
end = (guint8 *)file->map + file->len;
}
}
-stat_file_t *
-statfile_pool_open (statfile_pool_t * pool, gchar *filename, size_t size, gboolean forced)
+stat_file_t *
+statfile_pool_open (statfile_pool_t * pool,
+ gchar *filename,
+ size_t size,
+ gboolean forced)
{
- struct stat st;
- stat_file_t *new_file;
+ struct stat st;
+ stat_file_t *new_file;
if ((new_file = statfile_pool_is_open (pool, filename)) != NULL) {
return new_file;
}
if (pool->opened >= STATFILES_MAX - 1) {
- msg_err ("reached hard coded limit of statfiles opened: %d", STATFILES_MAX);
+ msg_err ("reached hard coded limit of statfiles opened: %d",
+ STATFILES_MAX);
return NULL;
}
if (stat (filename, &st) == -1) {
- msg_info ("cannot stat file %s, error %s, %d", filename, strerror (errno), errno);
+ msg_info ("cannot stat file %s, error %s, %d", filename, strerror (
+ errno), errno);
return NULL;
}
rspamd_mempool_lock_mutex (pool->lock);
- if (!forced && labs (size - st.st_size) > (long)sizeof (struct stat_file) * 2
- && size > sizeof (struct stat_file)) {
+ if (!forced &&
+ labs (size - st.st_size) > (long)sizeof (struct stat_file) * 2
+ && size > sizeof (struct stat_file)) {
rspamd_mempool_unlock_mutex (pool->lock);
- msg_warn ("need to reindex statfile old size: %Hz, new size: %Hz", (size_t)st.st_size, size);
+ msg_warn ("need to reindex statfile old size: %Hz, new size: %Hz",
+ (size_t)st.st_size, size);
return statfile_pool_reindex (pool, filename, st.st_size, size);
}
else if (size < sizeof (struct stat_file)) {
- msg_err ("requested to shrink statfile to %Hz but it is too small", size);
+ msg_err ("requested to shrink statfile to %Hz but it is too small",
+ size);
}
new_file = &pool->files[pool->opened++];
bzero (new_file, sizeof (stat_file_t));
if ((new_file->fd = open (filename, O_RDWR)) == -1) {
- msg_info ("cannot open file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot open file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
rspamd_mempool_unlock_mutex (pool->lock);
pool->opened--;
return NULL;
}
- if ((new_file->map = mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, new_file->fd, 0)) == MAP_FAILED) {
+ if ((new_file->map =
+ mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
+ new_file->fd, 0)) == MAP_FAILED) {
close (new_file->fd);
rspamd_mempool_unlock_mutex (pool->lock);
- msg_info ("cannot mmap file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot mmap file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
pool->opened--;
return NULL;
/* Try to lock pages in RAM */
if (pool->mlock_ok) {
if (mlock (new_file->map, new_file->len) == -1) {
- msg_warn ("mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s", strerror (errno));
+ msg_warn (
+ "mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s",
+ strerror (errno));
pool->mlock_ok = FALSE;
}
}
pool->opened--;
rspamd_mempool_unlock_mutex (pool->lock);
unlock_file (new_file->fd, FALSE);
- munmap (new_file->map, st.st_size);
+ munmap (new_file->map, st.st_size);
return NULL;
}
unlock_file (new_file->fd, FALSE);
}
gint
-statfile_pool_close (statfile_pool_t * pool, stat_file_t * file, gboolean keep_sorted)
+statfile_pool_close (statfile_pool_t * pool,
+ stat_file_t * file,
+ gboolean keep_sorted)
{
- stat_file_t *pos;
+ stat_file_t *pos;
if ((pos = statfile_pool_is_open (pool, file->filename)) == NULL) {
msg_info ("file %s is not opened", file->filename);
}
/* Move the remain statfiles */
memmove (pos, ((guint8 *)pos) + sizeof (stat_file_t),
- (--pool->opened - (pos - pool->files)) * sizeof (stat_file_t));
+ (--pool->opened - (pos - pool->files)) * sizeof (stat_file_t));
rspamd_mempool_unlock_mutex (pool->lock);
gint
statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
{
- struct stat_file_header header = {
+ struct stat_file_header header = {
.magic = {'r', 's', 'd'},
.version = RSPAMD_STATFILE_VERSION,
.padding = {0, 0, 0},
.rev_time = 0,
.used_blocks = 0
};
- struct stat_file_section section = {
+ struct stat_file_section section = {
.code = STATFILE_SECTION_COMMON,
};
- struct stat_file_block block = { 0, 0, 0 };
- gint fd;
- guint buflen = 0, nblocks;
- gchar *buf = NULL;
+ struct stat_file_block block = { 0, 0, 0 };
+ gint fd;
+ guint buflen = 0, nblocks;
+ gchar *buf = NULL;
if (statfile_pool_is_open (pool, filename) != NULL) {
msg_info ("file %s is already opened", filename);
}
if (size <
- sizeof (struct stat_file_header) + sizeof (struct stat_file_section) + sizeof (block)) {
- msg_err ("file %s is too small to carry any statistic: %z", filename, size);
+ sizeof (struct stat_file_header) + sizeof (struct stat_file_section) +
+ sizeof (block)) {
+ msg_err ("file %s is too small to carry any statistic: %z",
+ filename,
+ size);
return -1;
}
rspamd_mempool_lock_mutex (pool->lock);
- nblocks = (size - sizeof (struct stat_file_header) - sizeof (struct stat_file_section)) / sizeof (struct stat_file_block);
+ nblocks =
+ (size - sizeof (struct stat_file_header) -
+ sizeof (struct stat_file_section)) / sizeof (struct stat_file_block);
header.total_blocks = nblocks;
- if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
- msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
+ if ((fd =
+ open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+ msg_info ("cannot create file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
rspamd_mempool_unlock_mutex (pool->lock);
return -1;
}
- rspamd_fallocate (fd, 0, sizeof (header) + sizeof (section) + sizeof (block) * nblocks);
+ rspamd_fallocate (fd,
+ 0,
+ sizeof (header) + sizeof (section) + sizeof (block) * nblocks);
header.create_time = (guint64) time (NULL);
if (write (fd, &header, sizeof (header)) == -1) {
- msg_info ("cannot write header to file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot write header to file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
close (fd);
rspamd_mempool_unlock_mutex (pool->lock);
return -1;
section.length = (guint64) nblocks;
if (write (fd, §ion, sizeof (section)) == -1) {
- msg_info ("cannot write section header to file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot write section header to file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
close (fd);
rspamd_mempool_unlock_mutex (pool->lock);
return -1;
}
-
+
/* Buffer for write 256 blocks at once */
if (nblocks > 256) {
buflen = sizeof (block) * 256;
if (nblocks > 256) {
/* Just write buffer */
if (write (fd, buf, buflen) == -1) {
- msg_info ("cannot write blocks buffer to file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot write blocks buffer to file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
close (fd);
rspamd_mempool_unlock_mutex (pool->lock);
g_free (buf);
}
else {
if (write (fd, &block, sizeof (block)) == -1) {
- msg_info ("cannot write block to file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot write block to file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
close (fd);
if (buf) {
g_free (buf);
rspamd_mempool_unlock_mutex (pool->lock);
return -1;
}
- nblocks --;
+ nblocks--;
}
}
void
statfile_pool_delete (statfile_pool_t * pool)
{
- gint i;
+ gint i;
for (i = 0; i < pool->opened; i++) {
statfile_pool_close (pool, &pool->files[i], FALSE);
}
double
-statfile_pool_get_block (statfile_pool_t * pool, stat_file_t * file, guint32 h1, guint32 h2, time_t now)
+statfile_pool_get_block (statfile_pool_t * pool,
+ stat_file_t * file,
+ guint32 h1,
+ guint32 h2,
+ time_t now)
{
- struct stat_file_block *block;
- guint i, blocknum;
- u_char *c;
+ struct stat_file_block *block;
+ guint i, blocknum;
+ u_char *c;
file->access_time = now;
}
blocknum = h1 % file->cur_section.length;
- c = (u_char *) file->map + file->seek_pos + blocknum * sizeof (struct stat_file_block);
+ c = (u_char *) file->map + file->seek_pos + blocknum *
+ sizeof (struct stat_file_block);
block = (struct stat_file_block *)c;
for (i = 0; i < CHAIN_LENGTH; i++) {
}
static void
-statfile_pool_set_block_common (statfile_pool_t * pool, stat_file_t * file, guint32 h1, guint32 h2, time_t t, double value, gboolean from_now)
+statfile_pool_set_block_common (statfile_pool_t * pool,
+ stat_file_t * file,
+ guint32 h1,
+ guint32 h2,
+ time_t t,
+ double value,
+ gboolean from_now)
{
- struct stat_file_block *block, *to_expire = NULL;
- struct stat_file_header *header;
- guint i, blocknum;
- u_char *c;
- double min = G_MAXDOUBLE;
+ struct stat_file_block *block, *to_expire = NULL;
+ struct stat_file_header *header;
+ guint i, blocknum;
+ u_char *c;
+ double min = G_MAXDOUBLE;
if (from_now) {
file->access_time = t;
blocknum = h1 % file->cur_section.length;
header = (struct stat_file_header *)file->map;
- c = (u_char *) file->map + file->seek_pos + blocknum * sizeof (struct stat_file_block);
+ c = (u_char *) file->map + file->seek_pos + blocknum *
+ sizeof (struct stat_file_block);
block = (struct stat_file_block *)c;
for (i = 0; i < CHAIN_LENGTH; i++) {
if (i + blocknum >= file->cur_section.length) {
/* Need to expire some block in chain */
- msg_info ("chain %ud is full in statfile %s, starting expire", blocknum, file->filename);
+ msg_info ("chain %ud is full in statfile %s, starting expire",
+ blocknum,
+ file->filename);
break;
}
/* First try to find block in chain */
/* Check whether we have a free block in chain */
if (block->hash1 == 0 && block->hash2 == 0) {
/* Write new block here */
- msg_debug ("found free block %ud in chain %ud, set h1=%ud, h2=%ud", i, blocknum, h1, h2);
+ msg_debug ("found free block %ud in chain %ud, set h1=%ud, h2=%ud",
+ i,
+ blocknum,
+ h1,
+ h2);
block->hash1 = h1;
block->hash2 = h2;
block->value = value;
- header->used_blocks ++;
+ header->used_blocks++;
return;
}
-
+
/* Expire block with minimum value otherwise */
if (block->value < min) {
to_expire = block;
}
else {
/* Expire first block in chain */
- c = (u_char *) file->map + file->seek_pos + blocknum * sizeof (struct stat_file_block);
+ c = (u_char *) file->map + file->seek_pos + blocknum *
+ sizeof (struct stat_file_block);
block = (struct stat_file_block *)c;
}
}
void
-statfile_pool_set_block (statfile_pool_t * pool, stat_file_t * file, guint32 h1, guint32 h2, time_t now, double value)
+statfile_pool_set_block (statfile_pool_t * pool,
+ stat_file_t * file,
+ guint32 h1,
+ guint32 h2,
+ time_t now,
+ double value)
{
statfile_pool_set_block_common (pool, file, h1, h2, now, value, TRUE);
}
-stat_file_t *
+stat_file_t *
statfile_pool_is_open (statfile_pool_t * pool, gchar *filename)
{
- static stat_file_t f, *ret;
+ static stat_file_t f, *ret;
rspamd_strlcpy (f.filename, filename, sizeof (f.filename));
- ret = lfind (&f, pool->files, (size_t *)&pool->opened, sizeof (stat_file_t), cmpstatfile);
+ ret = lfind (&f,
+ pool->files,
+ (size_t *)&pool->opened,
+ sizeof (stat_file_t),
+ cmpstatfile);
return ret;
}
}
gboolean
-statfile_pool_set_section (statfile_pool_t * pool, stat_file_t * file, guint32 code, gboolean from_begin)
+statfile_pool_set_section (statfile_pool_t * pool,
+ stat_file_t * file,
+ guint32 code,
+ gboolean from_begin)
{
- struct stat_file_section *sec;
- off_t cur_offset;
+ struct stat_file_section *sec;
+ off_t cur_offset;
/* Try to find section */
}
gboolean
-statfile_pool_add_section (statfile_pool_t * pool, stat_file_t * file, guint32 code, guint64 length)
+statfile_pool_add_section (statfile_pool_t * pool,
+ stat_file_t * file,
+ guint32 code,
+ guint64 length)
{
- struct stat_file_section sect;
- struct stat_file_block block = { 0, 0, 0 };
+ struct stat_file_section sect;
+ struct stat_file_block block = { 0, 0, 0 };
if (lseek (file->fd, 0, SEEK_END) == -1) {
- msg_info ("cannot lseek file %s, error %d, %s", file->filename, errno, strerror (errno));
+ msg_info ("cannot lseek file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
sect.length = length;
if (write (file->fd, §, sizeof (sect)) == -1) {
- msg_info ("cannot write block to file %s, error %d, %s", file->filename, errno, strerror (errno));
+ msg_info ("cannot write block to file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
while (length--) {
if (write (file->fd, &block, sizeof (block)) == -1) {
- msg_info ("cannot write block to file %s, error %d, %s", file->filename, errno, strerror (errno));
+ msg_info ("cannot write block to file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
}
fsync (file->fd);
file->len += length;
- if ((file->map = mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd, 0)) == NULL) {
- msg_info ("cannot mmap file %s, error %d, %s", file->filename, errno, strerror (errno));
+ if ((file->map =
+ mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd,
+ 0)) == NULL) {
+ msg_info ("cannot mmap file %s, error %d, %s",
+ file->filename,
+ errno,
+ strerror (errno));
return FALSE;
}
statfile_pool_unlock_file (pool, file);
return 0;
}
-gboolean
+gboolean
statfile_set_revision (stat_file_t *file, guint64 rev, time_t time)
{
- struct stat_file_header *header;
+ struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
return FALSE;
}
-
+
header = (struct stat_file_header *)file->map;
header->revision = rev;
return TRUE;
}
-gboolean
+gboolean
statfile_inc_revision (stat_file_t *file)
{
- struct stat_file_header *header;
+ struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
return FALSE;
header = (struct stat_file_header *)file->map;
- header->revision ++;
+ header->revision++;
return TRUE;
}
gboolean
statfile_get_revision (stat_file_t *file, guint64 *rev, time_t *time)
{
- struct stat_file_header *header;
+ struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
return FALSE;
}
-
+
header = (struct stat_file_header *)file->map;
if (rev != NULL) {
return TRUE;
}
-guint64
+guint64
statfile_get_used_blocks (stat_file_t *file)
{
- struct stat_file_header *header;
+ struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
- return (guint64)-1;
+ return (guint64) - 1;
}
-
+
header = (struct stat_file_header *)file->map;
return header->used_blocks;
}
-guint64
+guint64
statfile_get_total_blocks (stat_file_t *file)
{
- struct stat_file_header *header;
+ struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
- return (guint64)-1;
+ return (guint64) - 1;
}
-
+
header = (struct stat_file_header *)file->map;
/* If total blocks is 0 we have old version of header, so set total blocks correctly */
static void
statfile_pool_invalidate_callback (gint fd, short what, void *ud)
{
- statfile_pool_t *pool = ud;
- stat_file_t *file;
- gint i;
+ statfile_pool_t *pool = ud;
+ stat_file_t *file;
+ gint i;
msg_info ("invalidating %d statfiles", pool->opened);
- for (i = 0; i < pool->opened; i ++) {
+ for (i = 0; i < pool->opened; i++) {
file = &pool->files[i];
msync (file->map, file->len, MS_ASYNC);
}
void
-statfile_pool_plan_invalidate (statfile_pool_t *pool, time_t seconds, time_t jitter)
+statfile_pool_plan_invalidate (statfile_pool_t *pool,
+ time_t seconds,
+ time_t jitter)
{
- gboolean pending;
+ gboolean pending;
if (pool->invalidate_event != NULL) {
pending = evtimer_pending (pool->invalidate_event, NULL);
if (pending) {
/* Replan event */
- pool->invalidate_tv.tv_sec = seconds + g_random_int_range (0, jitter);
+ pool->invalidate_tv.tv_sec = seconds +
+ g_random_int_range (0, jitter);
pool->invalidate_tv.tv_usec = 0;
evtimer_add (pool->invalidate_event, &pool->invalidate_tv);
}
}
else {
- pool->invalidate_event = rspamd_mempool_alloc (pool->pool, sizeof (struct event));
+ pool->invalidate_event =
+ rspamd_mempool_alloc (pool->pool, sizeof (struct event));
pool->invalidate_tv.tv_sec = seconds + g_random_int_range (0, jitter);
pool->invalidate_tv.tv_usec = 0;
- evtimer_set (pool->invalidate_event, statfile_pool_invalidate_callback, pool);
+ evtimer_set (pool->invalidate_event,
+ statfile_pool_invalidate_callback,
+ pool);
evtimer_add (pool->invalidate_event, &pool->invalidate_tv);
- msg_info ("invalidate of statfile pool is planned in %d seconds", (gint)pool->invalidate_tv.tv_sec);
+ msg_info ("invalidate of statfile pool is planned in %d seconds",
+ (gint)pool->invalidate_tv.tv_sec);
}
}
stat_file_t *
-get_statfile_by_symbol (statfile_pool_t *pool, struct rspamd_classifier_config *ccf,
- const gchar *symbol, struct rspamd_statfile_config **st, gboolean try_create)
+get_statfile_by_symbol (statfile_pool_t *pool,
+ struct rspamd_classifier_config *ccf,
+ const gchar *symbol,
+ struct rspamd_statfile_config **st,
+ gboolean try_create)
{
- stat_file_t *res = NULL;
- GList *cur;
+ stat_file_t *res = NULL;
+ GList *cur;
- if (pool == NULL || ccf == NULL || symbol == NULL) {
+ if (pool == NULL || ccf == NULL || symbol == NULL) {
msg_err ("invalid input arguments");
- return NULL;
- }
+ return NULL;
+ }
- cur = g_list_first (ccf->statfiles);
+ cur = g_list_first (ccf->statfiles);
while (cur) {
*st = cur->data;
if (strcmp (symbol, (*st)->symbol) == 0) {
*st = NULL;
cur = g_list_next (cur);
}
- if (*st == NULL) {
+ if (*st == NULL) {
msg_info ("cannot find statfile with symbol %s", symbol);
- return NULL;
- }
+ return NULL;
+ }
- if ((res = statfile_pool_is_open (pool, (*st)->path)) == NULL) {
- if ((res = statfile_pool_open (pool, (*st)->path, (*st)->size, FALSE)) == NULL) {
+ if ((res = statfile_pool_is_open (pool, (*st)->path)) == NULL) {
+ if ((res =
+ statfile_pool_open (pool, (*st)->path, (*st)->size,
+ FALSE)) == NULL) {
msg_warn ("cannot open %s", (*st)->path);
- if (try_create) {
- if (statfile_pool_create (pool, (*st)->path, (*st)->size) == -1) {
+ if (try_create) {
+ if (statfile_pool_create (pool, (*st)->path,
+ (*st)->size) == -1) {
msg_err ("cannot create statfile %s", (*st)->path);
return NULL;
}
- res = statfile_pool_open (pool, (*st)->path, (*st)->size, FALSE);
+ res =
+ statfile_pool_open (pool, (*st)->path, (*st)->size, FALSE);
if (res == NULL) {
- msg_err ("cannot open statfile %s after creation", (*st)->path);
+ msg_err ("cannot open statfile %s after creation",
+ (*st)->path);
}
- }
+ }
}
}
- return res;
+ return res;
}
void
gint i;
if (pool->mlock_ok) {
- for (i = 0; i < pool->opened; i ++) {
+ for (i = 0; i < pool->opened; i++) {
file = &pool->files[i];
if (mlock (file->map, file->len) == -1) {
- msg_warn ("mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s", strerror (errno));
+ msg_warn (
+ "mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s",
+ strerror (errno));
pool->mlock_ok = FALSE;
return;
}
#define RSPAMD_STATFILE_H
#include "config.h"
-#include "mem_pool.h"
#include "hash.h"
+#include "mem_pool.h"
#define CHAIN_LENGTH 128
* Common statfile header
*/
struct stat_file_header {
- u_char magic[3]; /**< magic signature ('r' 's' 'd') */
- u_char version[2]; /**< version of statfile */
- u_char padding[3]; /**< padding */
- guint64 create_time; /**< create time (time_t->guint64) */
- guint64 revision; /**< revision number */
- guint64 rev_time; /**< revision time */
- guint64 used_blocks; /**< used blocks number */
- guint64 total_blocks; /**< total number of blocks */
- u_char unused[239]; /**< some bytes that can be used in future */
+ u_char magic[3]; /**< magic signature ('r' 's' 'd') */
+ u_char version[2]; /**< version of statfile */
+ u_char padding[3]; /**< padding */
+ guint64 create_time; /**< create time (time_t->guint64) */
+ guint64 revision; /**< revision number */
+ guint64 rev_time; /**< revision time */
+ guint64 used_blocks; /**< used blocks number */
+ guint64 total_blocks; /**< total number of blocks */
+ u_char unused[239]; /**< some bytes that can be used in future */
};
/**
* Section header
*/
struct stat_file_section {
- guint64 code; /**< section's code */
- guint64 length; /**< section's length in blocks */
+ guint64 code; /**< section's code */
+ guint64 length; /**< section's length in blocks */
};
/**
* Block of data in statfile
*/
struct stat_file_block {
- guint32 hash1; /**< hash1 (also acts as index) */
- guint32 hash2; /**< hash2 */
- double value; /**< double value */
+ guint32 hash1; /**< hash1 (also acts as index) */
+ guint32 hash2; /**< hash2 */
+ double value; /**< double value */
};
/**
* Statistic file
*/
struct stat_file {
- struct stat_file_header header; /**< header */
- struct stat_file_section section; /**< first section */
- struct stat_file_block blocks[1]; /**< first block of data */
+ struct stat_file_header header; /**< header */
+ struct stat_file_section section; /**< first section */
+ struct stat_file_block blocks[1]; /**< first block of data */
};
/**
*/
typedef struct stat_file_s {
#ifdef HAVE_PATH_MAX
- gchar filename[PATH_MAX]; /**< name of file */
+ gchar filename[PATH_MAX]; /**< name of file */
#else
- gchar filename[MAXPATHLEN]; /**< name of file */
+ gchar filename[MAXPATHLEN]; /**< name of file */
#endif
- gint fd; /**< descriptor */
- void *map; /**< mmaped area */
- off_t seek_pos; /**< current seek position */
- struct stat_file_section cur_section; /**< current section */
- time_t open_time; /**< time when file was opened */
- time_t access_time; /**< last access time */
- size_t len; /**< length of file(in bytes) */
- rspamd_mempool_mutex_t *lock; /**< mutex */
+ gint fd; /**< descriptor */
+ void *map; /**< mmaped area */
+ off_t seek_pos; /**< current seek position */
+ struct stat_file_section cur_section; /**< current section */
+ time_t open_time; /**< time when file was opened */
+ time_t access_time; /**< last access time */
+ size_t len; /**< length of file(in bytes) */
+ rspamd_mempool_mutex_t *lock; /**< mutex */
} stat_file_t;
/**
* Statfiles pool
*/
typedef struct statfile_pool_s {
- stat_file_t *files; /**< hash table of opened files indexed by name */
- void **maps; /**< shared hash table of mmaped areas indexed by name */
- gint opened; /**< number of opened files */
- rspamd_mempool_t *pool; /**< memory pool object */
- rspamd_mempool_mutex_t *lock; /**< mutex */
- struct event *invalidate_event; /**< event for pool invalidation */
+ stat_file_t *files; /**< hash table of opened files indexed by name */
+ void **maps; /**< shared hash table of mmaped areas indexed by name */
+ gint opened; /**< number of opened files */
+ rspamd_mempool_t *pool; /**< memory pool object */
+ rspamd_mempool_mutex_t *lock; /**< mutex */
+ struct event *invalidate_event; /**< event for pool invalidation */
struct timeval invalidate_tv;
- gboolean mlock_ok; /**< whether it is possible to use mlock (2) to avoid statfiles unloading */
+ gboolean mlock_ok; /**< whether it is possible to use mlock (2) to avoid statfiles unloading */
} statfile_pool_t;
/* Forwarded declarations */
* @param max_size maximum size
* @return statfile pool object
*/
-statfile_pool_t* statfile_pool_new (rspamd_mempool_t *pool, gboolean use_mlock);
+statfile_pool_t * statfile_pool_new (rspamd_mempool_t *pool,
+ gboolean use_mlock);
/**
* Open statfile and attach it to pool
* @param filename name of statfile to open
* @return 0 if specified statfile is attached and -1 in case of error
*/
-stat_file_t* statfile_pool_open (statfile_pool_t *pool, gchar *filename, size_t len, gboolean forced);
+stat_file_t * statfile_pool_open (statfile_pool_t *pool,
+ gchar *filename,
+ size_t len,
+ gboolean forced);
/**
* Create new statfile but DOES NOT attach it to pool, use @see statfile_pool_open for attaching
* @param remove_hash remove filename from opened files hash also
* @return 0 if file was closed and -1 if statfile was not opened
*/
-gint statfile_pool_close (statfile_pool_t *pool, stat_file_t *file, gboolean keep_sorted);
+gint statfile_pool_close (statfile_pool_t *pool,
+ stat_file_t *file,
+ gboolean keep_sorted);
/**
* Delete statfile pool and close all attached statfiles
* @param now current time
* @return block value or 0 if block is not found
*/
-double statfile_pool_get_block (statfile_pool_t *pool, stat_file_t *file, guint32 h1, guint32 h2, time_t now);
+double statfile_pool_get_block (statfile_pool_t *pool,
+ stat_file_t *file,
+ guint32 h1,
+ guint32 h2,
+ time_t now);
/**
* Set specified block in statfile
* @param now current time
* @param value value of block
*/
-void statfile_pool_set_block (statfile_pool_t *pool, stat_file_t *file, guint32 h1, guint32 h2, time_t now, double value);
+void statfile_pool_set_block (statfile_pool_t *pool,
+ stat_file_t *file,
+ guint32 h1,
+ guint32 h2,
+ time_t now,
+ double value);
/**
* Check whether statfile is opened
* @param filename name of statfile
* @return TRUE if specified statfile is opened and FALSE otherwise
*/
-stat_file_t* statfile_pool_is_open (statfile_pool_t *pool, gchar *filename);
+stat_file_t * statfile_pool_is_open (statfile_pool_t *pool, gchar *filename);
/**
* Returns current statfile section
* @param from_begin search for section from begin of file if true
* @return TRUE if section was set and FALSE otherwise
*/
-gboolean statfile_pool_set_section (statfile_pool_t *pool, stat_file_t *file, guint32 code, gboolean from_begin);
+gboolean statfile_pool_set_section (statfile_pool_t *pool,
+ stat_file_t *file,
+ guint32 code,
+ gboolean from_begin);
/**
* Add new section to statfile
* @param length length in blocks of new section
* @return TRUE if section was successfully added and FALSE in case of error
*/
-gboolean statfile_pool_add_section (statfile_pool_t *pool, stat_file_t *file, guint32 code, guint64 length);
+gboolean statfile_pool_add_section (statfile_pool_t *pool,
+ stat_file_t *file,
+ guint32 code,
+ guint64 length);
/**
/**
* Plan statfile pool invalidation
*/
-void statfile_pool_plan_invalidate (statfile_pool_t *pool, time_t seconds, time_t jitter);
+void statfile_pool_plan_invalidate (statfile_pool_t *pool,
+ time_t seconds,
+ time_t jitter);
/**
* Get a statfile by symbol
* @param st statfile to get
* @param try_create whether we need to create statfile if it is absent
*/
-stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct rspamd_classifier_config *ccf,
- const gchar *symbol, struct rspamd_statfile_config **st, gboolean try_create);
+stat_file_t * get_statfile_by_symbol (statfile_pool_t *pool,
+ struct rspamd_classifier_config *ccf,
+ const gchar *symbol,
+ struct rspamd_statfile_config **st,
+ gboolean try_create);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
+#include "binlog.h"
+#include "buffer.h"
#include "cfg_file.h"
-#include "tokenizers/tokenizers.h"
#include "classifiers/classifiers.h"
+#include "config.h"
#include "statfile.h"
-#include "binlog.h"
-#include "buffer.h"
#include "statfile_sync.h"
+#include "tokenizers/tokenizers.h"
enum rspamd_sync_state {
SYNC_STATE_GREETING,
enum rspamd_sync_state state;
gboolean is_busy;
- guint64 new_rev;
- guint64 new_time;
- guint64 new_len;
+ guint64 new_rev;
+ guint64 new_time;
+ guint64 new_len;
};
static void
log_next_sync (const gchar *symbol, time_t delay)
{
- gchar outstr[200];
- time_t t;
+ gchar outstr[200];
+ time_t t;
struct tm *tmp;
- gint r;
+ gint r;
- t = time(NULL);
+ t = time (NULL);
t += delay;
- tmp = localtime(&t);
+ tmp = localtime (&t);
if (tmp) {
- r = rspamd_snprintf (outstr, sizeof (outstr), "statfile_sync: next sync of %s at ", symbol);
- if ((r = strftime(outstr + r, sizeof(outstr) - r, "%T", tmp)) != 0) {
+ r = rspamd_snprintf (outstr,
+ sizeof (outstr),
+ "statfile_sync: next sync of %s at ",
+ symbol);
+ if ((r = strftime (outstr + r, sizeof(outstr) - r, "%T", tmp)) != 0) {
msg_info (outstr);
}
}
}
-static gboolean
+static gboolean
parse_revision_line (struct rspamd_sync_ctx *ctx, f_str_t *in)
{
- guint i, state = 0;
- gchar *p, *c, numbuf[sizeof("18446744073709551615")];
- guint64 *val;
+ guint i, state = 0;
+ gchar *p, *c, numbuf[sizeof("18446744073709551615")];
+ guint64 *val;
/* First of all try to find END line */
- if (in->len >= sizeof ("END") - 1 && memcmp (in->begin, "END", sizeof ("END") - 1) == 0) {
+ if (in->len >= sizeof ("END") - 1 &&
+ memcmp (in->begin, "END", sizeof ("END") - 1) == 0) {
ctx->state = SYNC_STATE_QUIT;
ctx->is_busy = FALSE;
return TRUE;
}
/* Next check for error line */
- if (in->len >= sizeof ("FAIL") - 1 && memcmp (in->begin, "FAIL", sizeof ("FAIL") - 1) == 0) {
+ if (in->len >= sizeof ("FAIL") - 1 &&
+ memcmp (in->begin, "FAIL", sizeof ("FAIL") - 1) == 0) {
ctx->state = SYNC_STATE_QUIT;
ctx->is_busy = FALSE;
return TRUE;
}
-
+
/* Now try to extract 3 numbers from string: revision, time and length */
p = in->begin;
val = &ctx->new_rev;
- for (i = 0; i < in->len; i ++, p ++) {
+ for (i = 0; i < in->len; i++, p++) {
if (g_ascii_isspace (*p) || i == in->len - 1) {
if (state == 1) {
if (i == in->len - 1) {
/* One more character */
- p ++;
+ p++;
}
- rspamd_strlcpy (numbuf, c, MIN (p - c + 1, (gint)sizeof (numbuf)));
+ rspamd_strlcpy (numbuf, c, MIN (p - c + 1,
+ (gint)sizeof (numbuf)));
errno = 0;
*val = strtoull (numbuf, NULL, 10);
if (errno != 0) {
return ((val == &ctx->new_len));
}
-static gboolean
+static gboolean
read_blocks (struct rspamd_sync_ctx *ctx, f_str_t *in)
{
struct rspamd_binlog_element *elt;
- guint i;
-
+ guint i;
+
statfile_pool_lock_file (ctx->pool, ctx->real_statfile);
elt = (struct rspamd_binlog_element *)in->begin;
- for (i = 0; i < in->len / sizeof (struct rspamd_binlog_element); i ++, elt ++) {
- statfile_pool_set_block (ctx->pool, ctx->real_statfile, elt->h1, elt->h2, ctx->new_time, elt->value);
+ for (i = 0; i < in->len / sizeof (struct rspamd_binlog_element); i++,
+ elt++) {
+ statfile_pool_set_block (ctx->pool,
+ ctx->real_statfile,
+ elt->h1,
+ elt->h2,
+ ctx->new_time,
+ elt->value);
}
statfile_pool_unlock_file (ctx->pool, ctx->real_statfile);
return TRUE;
}
-static gboolean
+static gboolean
sync_read (f_str_t * in, void *arg)
{
struct rspamd_sync_ctx *ctx = arg;
- gchar buf[256];
- guint64 rev = 0;
- time_t ti = 0;
+ gchar buf[256];
+ guint64 rev = 0;
+ time_t ti = 0;
if (in->len == 0) {
/* Skip empty lines */
return TRUE;
}
switch (ctx->state) {
- case SYNC_STATE_GREETING:
- /* Skip greeting line and write sync command */
- /* Write initial data */
- statfile_get_revision (ctx->real_statfile, &rev, &ti);
- rev = rspamd_snprintf (buf, sizeof (buf), "sync %s %uL %T" CRLF, ctx->st->symbol, rev, ti);
- ctx->state = SYNC_STATE_READ_LINE;
- return rspamd_dispatcher_write (ctx->dispatcher, buf, rev, FALSE, FALSE);
- break;
- case SYNC_STATE_READ_LINE:
- /* Try to parse line from server */
- if (!parse_revision_line (ctx, in)) {
- msg_info ("cannot parse line of length %z: '%*s'", in->len, (gint)in->len, in->begin);
- close (ctx->sock);
- rspamd_remove_dispatcher (ctx->dispatcher);
- ctx->is_busy = FALSE;
- return FALSE;
- }
- else if (ctx->state != SYNC_STATE_QUIT) {
- if (ctx->new_len > 0) {
- ctx->state = SYNC_STATE_READ_REV;
- rspamd_set_dispatcher_policy (ctx->dispatcher, BUFFER_CHARACTER, ctx->new_len);
- }
- }
- else {
- /* Quit this session */
- msg_info ("sync ended for: %s", ctx->st->symbol);
- close (ctx->sock);
- rspamd_remove_dispatcher (ctx->dispatcher);
- ctx->is_busy = FALSE;
- /* Immediately return from callback */
- return FALSE;
- }
- break;
- case SYNC_STATE_READ_REV:
- /* In now contains all blocks of specified revision, so we can read them directly */
- if (!read_blocks (ctx, in)) {
- msg_info ("cannot read blocks");
- close (ctx->sock);
- rspamd_remove_dispatcher (ctx->dispatcher);
- ctx->is_busy = FALSE;
- return FALSE;
+ case SYNC_STATE_GREETING:
+ /* Skip greeting line and write sync command */
+ /* Write initial data */
+ statfile_get_revision (ctx->real_statfile, &rev, &ti);
+ rev = rspamd_snprintf (buf,
+ sizeof (buf),
+ "sync %s %uL %T" CRLF,
+ ctx->st->symbol,
+ rev,
+ ti);
+ ctx->state = SYNC_STATE_READ_LINE;
+ return rspamd_dispatcher_write (ctx->dispatcher, buf, rev, FALSE,
+ FALSE);
+ break;
+ case SYNC_STATE_READ_LINE:
+ /* Try to parse line from server */
+ if (!parse_revision_line (ctx, in)) {
+ msg_info ("cannot parse line of length %z: '%*s'",
+ in->len,
+ (gint)in->len,
+ in->begin);
+ close (ctx->sock);
+ rspamd_remove_dispatcher (ctx->dispatcher);
+ ctx->is_busy = FALSE;
+ return FALSE;
+ }
+ else if (ctx->state != SYNC_STATE_QUIT) {
+ if (ctx->new_len > 0) {
+ ctx->state = SYNC_STATE_READ_REV;
+ rspamd_set_dispatcher_policy (ctx->dispatcher,
+ BUFFER_CHARACTER,
+ ctx->new_len);
}
- statfile_set_revision (ctx->real_statfile, ctx->new_rev, ctx->new_time);
- msg_info ("set new revision: %uL, readed %z bytes", ctx->new_rev, in->len);
- /* Now try to read other revision or END line */
- ctx->state = SYNC_STATE_READ_LINE;
- rspamd_set_dispatcher_policy (ctx->dispatcher, BUFFER_LINE, 0);
- break;
- case SYNC_STATE_QUIT:
+ }
+ else {
+ /* Quit this session */
+ msg_info ("sync ended for: %s", ctx->st->symbol);
+ close (ctx->sock);
+ rspamd_remove_dispatcher (ctx->dispatcher);
+ ctx->is_busy = FALSE;
+ /* Immediately return from callback */
+ return FALSE;
+ }
+ break;
+ case SYNC_STATE_READ_REV:
+ /* In now contains all blocks of specified revision, so we can read them directly */
+ if (!read_blocks (ctx, in)) {
+ msg_info ("cannot read blocks");
close (ctx->sock);
rspamd_remove_dispatcher (ctx->dispatcher);
ctx->is_busy = FALSE;
return FALSE;
+ }
+ statfile_set_revision (ctx->real_statfile, ctx->new_rev, ctx->new_time);
+ msg_info ("set new revision: %uL, readed %z bytes",
+ ctx->new_rev,
+ in->len);
+ /* Now try to read other revision or END line */
+ ctx->state = SYNC_STATE_READ_LINE;
+ rspamd_set_dispatcher_policy (ctx->dispatcher, BUFFER_LINE, 0);
+ break;
+ case SYNC_STATE_QUIT:
+ close (ctx->sock);
+ rspamd_remove_dispatcher (ctx->dispatcher);
+ ctx->is_busy = FALSE;
+ return FALSE;
}
return TRUE;
}
-static void
+static void
sync_err (GError *err, void *arg)
{
struct rspamd_sync_ctx *ctx = arg;
{
struct rspamd_sync_ctx *ctx = ud;
guint32 jittered_interval;
-
+
/* Plan new event */
evtimer_del (&ctx->tm_ev);
/* Add some jittering for synchronization */
- jittered_interval = g_random_int_range (ctx->sync_interval, ctx->sync_interval * 2);
+ jittered_interval = g_random_int_range (ctx->sync_interval,
+ ctx->sync_interval * 2);
msec_to_tv (jittered_interval, &ctx->interval);
evtimer_add (&ctx->tm_ev, &ctx->interval);
log_next_sync (ctx->st->symbol, ctx->interval.tv_sec);
-
+
if (ctx->is_busy) {
/* Sync is in progress */
msg_info ("syncronization process is in progress, do not start new one");
return;
}
- if ((ctx->sock = make_universal_socket (ctx->st->binlog->master_addr, ctx->st->binlog->master_port,
- SOCK_STREAM, TRUE, FALSE, TRUE)) == -1) {
+ if ((ctx->sock =
+ make_universal_socket (ctx->st->binlog->master_addr,
+ ctx->st->binlog->master_port,
+ SOCK_STREAM, TRUE, FALSE, TRUE)) == -1) {
msg_info ("cannot connect to %s", ctx->st->binlog->master_addr);
return;
}
/* Now create and activate dispatcher */
msec_to_tv (ctx->timeout, &ctx->io_tv);
- ctx->dispatcher = rspamd_create_dispatcher (ctx->ev_base, ctx->sock, BUFFER_LINE, sync_read, NULL, sync_err, &ctx->io_tv, ctx);
-
+ ctx->dispatcher = rspamd_create_dispatcher (ctx->ev_base,
+ ctx->sock,
+ BUFFER_LINE,
+ sync_read,
+ NULL,
+ sync_err,
+ &ctx->io_tv,
+ ctx);
+
ctx->state = SYNC_STATE_GREETING;
ctx->is_busy = TRUE;
}
static gboolean
-add_statfile_watch (statfile_pool_t *pool, struct rspamd_statfile_config *st, struct rspamd_config *cfg, struct event_base *ev_base)
+add_statfile_watch (statfile_pool_t *pool,
+ struct rspamd_statfile_config *st,
+ struct rspamd_config *cfg,
+ struct event_base *ev_base)
{
struct rspamd_sync_ctx *ctx;
guint32 jittered_interval;
-
+
if (st->binlog->master_addr != NULL) {
- ctx = rspamd_mempool_alloc (pool->pool, sizeof (struct rspamd_sync_ctx));
+ ctx =
+ rspamd_mempool_alloc (pool->pool, sizeof (struct rspamd_sync_ctx));
ctx->st = st;
ctx->timeout = cfg->statfile_sync_timeout;
ctx->sync_interval = cfg->statfile_sync_interval;
ctx->ev_base = ev_base;
/* Add some jittering for synchronization */
- jittered_interval = g_random_int_range (ctx->sync_interval, ctx->sync_interval * 2);
+ jittered_interval = g_random_int_range (ctx->sync_interval,
+ ctx->sync_interval * 2);
msec_to_tv (jittered_interval, &ctx->interval);
/* Open statfile and attach it to pool */
- if ((ctx->real_statfile = statfile_pool_is_open (pool, st->path)) == NULL) {
- if ((ctx->real_statfile = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+ if ((ctx->real_statfile =
+ statfile_pool_is_open (pool, st->path)) == NULL) {
+ if ((ctx->real_statfile =
+ statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
msg_warn ("cannot open %s", st->path);
if (statfile_pool_create (pool, st->path, st->size) == -1) {
msg_err ("cannot create statfile %s", st->path);
return FALSE;
}
- ctx->real_statfile = statfile_pool_open (pool, st->path, st->size, FALSE);
+ ctx->real_statfile = statfile_pool_open (pool,
+ st->path,
+ st->size,
+ FALSE);
}
}
/* Now plan event for it's future executing */
log_next_sync (st->symbol, ctx->interval.tv_sec);
}
else {
- msg_err ("cannot add statfile watch for statfile %s: no master defined", st->symbol);
+ msg_err ("cannot add statfile watch for statfile %s: no master defined",
+ st->symbol);
return FALSE;
}
return TRUE;
}
-gboolean
-start_statfile_sync (statfile_pool_t *pool, struct rspamd_config *cfg, struct event_base *ev_base)
+gboolean
+start_statfile_sync (statfile_pool_t *pool,
+ struct rspamd_config *cfg,
+ struct event_base *ev_base)
{
GList *cur, *l;
struct rspamd_classifier_config *cl;
struct rspamd_statfile_config *st;
- /*
+ /*
* First of all walk through all classifiers and find those statfiles
* for which we should do sync (slave affinity)
*/
#ifndef RSPAMD_STATFILE_SYNC_H
#define RSPAMD_STATFILE_SYNC_H
+#include "cfg_file.h"
#include "config.h"
#include "main.h"
#include "statfile.h"
-#include "cfg_file.h"
/*
* Start synchronization of statfiles. Must be called after event_init as it adds events
*/
-gboolean start_statfile_sync (statfile_pool_t *pool, struct rspamd_config *cfg, struct event_base *ev_base);
+gboolean start_statfile_sync (statfile_pool_t *pool,
+ struct rspamd_config *cfg,
+ struct event_base *ev_base);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "cfg_file.h"
#include "config.h"
-#include "util.h"
#include "main.h"
#include "message.h"
#include "symbols_cache.h"
-#include "cfg_file.h"
+#include "util.h"
#define WEIGHT_MULT 4.0
#define FREQUENCY_MULT 10.0
#define MIN_CACHE 17
-static guint64 total_frequency = 0;
-static guint32 nsymbols = 0;
+static guint64 total_frequency = 0;
+static guint32 nsymbols = 0;
gint
cache_cmp (const void *p1, const void *p2)
{
- const struct cache_item *i1 = p1, *i2 = p2;
+ const struct cache_item *i1 = p1, *i2 = p2;
return strcmp (i1->s->symbol, i2->s->symbol);
}
gint
cache_logic_cmp (const void *p1, const void *p2)
{
- const struct cache_item *i1 = p1, *i2 = p2;
- double w1, w2;
- double weight1, weight2;
- double f1 = 0, f2 = 0;
+ const struct cache_item *i1 = p1, *i2 = p2;
+ double w1, w2;
+ double weight1, weight2;
+ double f1 = 0, f2 = 0;
if (i1->priority == 0 && i2->priority == 0) {
if (total_frequency > 0) {
- f1 = ((double)i1->s->frequency * nsymbols) / (double)total_frequency;
- f2 = ((double)i2->s->frequency * nsymbols) / (double)total_frequency;
+ f1 =
+ ((double)i1->s->frequency * nsymbols) / (double)total_frequency;
+ f2 =
+ ((double)i2->s->frequency * nsymbols) / (double)total_frequency;
}
weight1 = i1->metric_weight == 0 ? i1->s->weight : i1->metric_weight;
weight2 = i2->metric_weight == 0 ? i2->s->weight : i2->metric_weight;
- w1 = abs (weight1) * WEIGHT_MULT + f1 * FREQUENCY_MULT + i1->s->avg_time * TIME_MULT;
- w2 = abs (weight2) * WEIGHT_MULT + f2 * FREQUENCY_MULT + i2->s->avg_time * TIME_MULT;
+ w1 = abs (weight1) * WEIGHT_MULT + f1 * FREQUENCY_MULT +
+ i1->s->avg_time * TIME_MULT;
+ w2 = abs (weight2) * WEIGHT_MULT + f2 * FREQUENCY_MULT +
+ i2->s->avg_time * TIME_MULT;
}
else {
/* Strict sorting */
return (gint)w2 - w1;
}
-static GChecksum *
+static GChecksum *
get_mem_cksum (struct symbols_cache *cache)
{
- GChecksum *result;
- GList *cur, *l;
- struct cache_item *item;
+ GChecksum *result;
+ GList *cur, *l;
+ struct cache_item *item;
result = g_checksum_new (G_CHECKSUM_SHA1);
while (cur) {
item = cur->data;
if (item->s->symbol[0] != '\0') {
- g_checksum_update (result, item->s->symbol, strlen (item->s->symbol));
+ g_checksum_update (result, item->s->symbol,
+ strlen (item->s->symbol));
}
cur = g_list_next (cur);
}
while (cur) {
item = cur->data;
if (item->s->symbol[0] != '\0') {
- g_checksum_update (result, item->s->symbol, strlen (item->s->symbol));
+ g_checksum_update (result, item->s->symbol,
+ strlen (item->s->symbol));
}
total_frequency += item->s->frequency;
cur = g_list_next (cur);
static void
post_cache_init (struct symbols_cache *cache)
{
- GList *cur;
- struct cache_item *item;
+ GList *cur;
+ struct cache_item *item;
total_frequency = 0;
nsymbols = cache->used_items;
cur = g_list_next (cur);
}
- cache->negative_items = g_list_sort (cache->negative_items, cache_logic_cmp);
+ cache->negative_items =
+ g_list_sort (cache->negative_items, cache_logic_cmp);
cache->static_items = g_list_sort (cache->static_items, cache_logic_cmp);
}
static void
unmap_cache_file (gpointer arg)
{
- struct symbols_cache *cache = arg;
-
+ struct symbols_cache *cache = arg;
+
/* A bit ugly usage */
munmap (cache->map, cache->used_items * sizeof (struct saved_cache_item));
}
-static gboolean
+static gboolean
mmap_cache_file (struct symbols_cache *cache, gint fd, rspamd_mempool_t *pool)
{
- guint8 *map;
- gint i;
- GList *cur;
- struct cache_item *item;
+ guint8 *map;
+ gint i;
+ GList *cur;
+ struct cache_item *item;
if (cache->used_items > 0) {
- map = mmap (NULL, cache->used_items * sizeof (struct saved_cache_item), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ map = mmap (NULL,
+ cache->used_items * sizeof (struct saved_cache_item),
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED,
+ fd,
+ 0);
if (map == MAP_FAILED) {
msg_err ("cannot mmap cache file: %d, %s", errno, strerror (errno));
close (fd);
cur = g_list_first (cache->negative_items);
while (cur) {
item = cur->data;
- item->s = (struct saved_cache_item *)(map + i * sizeof (struct saved_cache_item));
+ item->s =
+ (struct saved_cache_item *)(map + i *
+ sizeof (struct saved_cache_item));
cur = g_list_next (cur);
- i ++;
+ i++;
}
cur = g_list_first (cache->static_items);
while (cur) {
item = cur->data;
- item->s = (struct saved_cache_item *)(map + i * sizeof (struct saved_cache_item));
+ item->s =
+ (struct saved_cache_item *)(map + i *
+ sizeof (struct saved_cache_item));
cur = g_list_next (cur);
- i ++;
+ i++;
}
post_cache_init (cache);
}
/* Fd must be opened for writing, after creating file is mmapped */
-static gboolean
-create_cache_file (struct symbols_cache *cache, const gchar *filename, gint fd, rspamd_mempool_t *pool)
+static gboolean
+create_cache_file (struct symbols_cache *cache,
+ const gchar *filename,
+ gint fd,
+ rspamd_mempool_t *pool)
{
- GChecksum *cksum;
- u_char *digest;
- gsize cklen;
- GList *cur;
- struct cache_item *item;
+ GChecksum *cksum;
+ u_char *digest;
+ gsize cklen;
+ GList *cur;
+ struct cache_item *item;
/* Calculate checksum */
cksum = get_mem_cksum (cache);
};
static void
-register_symbol_common (struct symbols_cache **cache, const gchar *name, double weight, gint priority,
- symbol_func_t func, gpointer user_data, enum rspamd_symbol_type type)
+register_symbol_common (struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ gint priority,
+ symbol_func_t func,
+ gpointer user_data,
+ enum rspamd_symbol_type type)
{
- struct cache_item *item = NULL;
- struct symbols_cache *pcache = *cache;
- GList **target;
- double *w;
+ struct cache_item *item = NULL;
+ struct symbols_cache *pcache = *cache;
+ GList **target;
+ double *w;
if (*cache == NULL) {
pcache = g_new0 (struct symbols_cache, 1);
*cache = pcache;
- pcache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
- pcache->items_by_symbol = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ pcache->static_pool =
+ rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ pcache->items_by_symbol = g_hash_table_new (rspamd_str_hash,
+ rspamd_str_equal);
}
-
- item = rspamd_mempool_alloc0 (pcache->static_pool, sizeof (struct cache_item));
- item->s = rspamd_mempool_alloc0 (pcache->static_pool, sizeof (struct saved_cache_item));
+
+ item = rspamd_mempool_alloc0 (pcache->static_pool,
+ sizeof (struct cache_item));
+ item->s =
+ rspamd_mempool_alloc0 (pcache->static_pool,
+ sizeof (struct saved_cache_item));
rspamd_strlcpy (item->s->symbol, name, sizeof (item->s->symbol));
item->func = func;
item->user_data = user_data;
}
/* Handle weight using default metric */
- if (pcache->cfg && pcache->cfg->default_metric && (w = g_hash_table_lookup (pcache->cfg->default_metric->symbols, name)) != NULL) {
+ if (pcache->cfg && pcache->cfg->default_metric &&
+ (w =
+ g_hash_table_lookup (pcache->cfg->default_metric->symbols,
+ name)) != NULL) {
item->s->weight = weight * (*w);
}
else {
void
register_symbol (struct symbols_cache **cache, const gchar *name, double weight,
- symbol_func_t func, gpointer user_data)
+ symbol_func_t func, gpointer user_data)
{
- register_symbol_common (cache, name, weight, 0, func, user_data, SYMBOL_TYPE_NORMAL);
+ register_symbol_common (cache,
+ name,
+ weight,
+ 0,
+ func,
+ user_data,
+ SYMBOL_TYPE_NORMAL);
}
void
-register_virtual_symbol (struct symbols_cache **cache, const gchar *name, double weight)
+register_virtual_symbol (struct symbols_cache **cache,
+ const gchar *name,
+ double weight)
{
- register_symbol_common (cache, name, weight, 0, NULL, NULL, SYMBOL_TYPE_VIRTUAL);
+ register_symbol_common (cache,
+ name,
+ weight,
+ 0,
+ NULL,
+ NULL,
+ SYMBOL_TYPE_VIRTUAL);
}
void
-register_callback_symbol (struct symbols_cache **cache, const gchar *name, double weight,
- symbol_func_t func, gpointer user_data)
+register_callback_symbol (struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ symbol_func_t func,
+ gpointer user_data)
{
- register_symbol_common (cache, name, weight, 0, func, user_data, SYMBOL_TYPE_CALLBACK);
+ register_symbol_common (cache,
+ name,
+ weight,
+ 0,
+ func,
+ user_data,
+ SYMBOL_TYPE_CALLBACK);
}
void
-register_callback_symbol_priority (struct symbols_cache **cache, const gchar *name, double weight, gint priority,
- symbol_func_t func, gpointer user_data)
+register_callback_symbol_priority (struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ gint priority,
+ symbol_func_t func,
+ gpointer user_data)
{
- register_symbol_common (cache, name, weight, priority, func, user_data, SYMBOL_TYPE_CALLBACK);
+ register_symbol_common (cache,
+ name,
+ weight,
+ priority,
+ func,
+ user_data,
+ SYMBOL_TYPE_CALLBACK);
}
void
-register_dynamic_symbol (rspamd_mempool_t *dynamic_pool, struct symbols_cache **cache,
- const gchar *name, double weight, symbol_func_t func,
- gpointer user_data, GList *networks)
+register_dynamic_symbol (rspamd_mempool_t *dynamic_pool,
+ struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ symbol_func_t func,
+ gpointer user_data,
+ GList *networks)
{
- struct cache_item *item = NULL;
- struct symbols_cache *pcache = *cache;
- GList *t, *cur;
- uintptr_t r;
- double *w;
- guint32 mask = 0xFFFFFFFF;
- struct dynamic_map_item *it;
- gint rr;
+ struct cache_item *item = NULL;
+ struct symbols_cache *pcache = *cache;
+ GList *t, *cur;
+ uintptr_t r;
+ double *w;
+ guint32 mask = 0xFFFFFFFF;
+ struct dynamic_map_item *it;
+ gint rr;
if (*cache == NULL) {
pcache = g_new0 (struct symbols_cache, 1);
*cache = pcache;
- pcache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ pcache->static_pool =
+ rspamd_mempool_new (rspamd_mempool_suggest_size ());
}
-
+
item = rspamd_mempool_alloc0 (dynamic_pool, sizeof (struct cache_item));
- item->s = rspamd_mempool_alloc (dynamic_pool, sizeof (struct saved_cache_item));
+ item->s =
+ rspamd_mempool_alloc (dynamic_pool, sizeof (struct saved_cache_item));
rspamd_strlcpy (item->s->symbol, name, sizeof (item->s->symbol));
item->func = func;
item->user_data = user_data;
/* Handle weight using default metric */
- if (pcache->cfg && pcache->cfg->default_metric && (w = g_hash_table_lookup (pcache->cfg->default_metric->symbols, name)) != NULL) {
+ if (pcache->cfg && pcache->cfg->default_metric &&
+ (w =
+ g_hash_table_lookup (pcache->cfg->default_metric->symbols,
+ name)) != NULL) {
item->s->weight = weight * (*w);
}
else {
pcache->used_items++;
msg_debug ("used items: %d, added symbol: %s", (*cache)->used_items, name);
rspamd_set_counter (item->s->symbol, 0);
-
+
g_hash_table_insert (pcache->items_by_symbol, item->s->symbol, item);
if (networks == NULL) {
r = ntohl (it->addr.s_addr & mask);
if (it->negative) {
/* For negatve items insert into list and into negative cache map */
- if ((r = radix32tree_find (pcache->negative_dynamic_map, r)) != RADIX_NO_VALUE) {
+ if ((r =
+ radix32tree_find (pcache->negative_dynamic_map,
+ r)) != RADIX_NO_VALUE) {
t = (GList *)((gpointer)r);
t = g_list_prepend (t, item);
/* Replace pointers in radix tree and in destructor function */
- rspamd_mempool_replace_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
- rr = radix32tree_replace (pcache->negative_dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
+ rspamd_mempool_replace_destructor (dynamic_pool,
+ (rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
+ rr = radix32tree_replace (pcache->negative_dynamic_map,
+ ntohl (it->addr.s_addr),
+ mask,
+ (uintptr_t)t);
if (rr == -1) {
- msg_warn ("cannot replace ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
+ msg_warn ("cannot replace ip to tree: %s, mask %X",
+ inet_ntoa (it->addr),
+ mask);
}
}
else {
t = g_list_prepend (NULL, item);
- rspamd_mempool_add_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, t);
- rr = radix32tree_insert (pcache->negative_dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
+ rspamd_mempool_add_destructor (dynamic_pool,
+ (rspamd_mempool_destruct_t)g_list_free, t);
+ rr = radix32tree_insert (pcache->negative_dynamic_map,
+ ntohl (it->addr.s_addr),
+ mask,
+ (uintptr_t)t);
if (rr == -1) {
- msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
+ msg_warn ("cannot insert ip to tree: %s, mask %X",
+ inet_ntoa (it->addr),
+ mask);
}
else if (rr == 1) {
- msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (it->addr), mask);
+ msg_warn ("ip %s, mask %X, value already exists",
+ inet_ntoa (it->addr),
+ mask);
}
}
/* Insert into list */
- pcache->dynamic_items = g_list_prepend (pcache->dynamic_items, item);
+ pcache->dynamic_items = g_list_prepend (pcache->dynamic_items,
+ item);
}
else {
- if ((r = radix32tree_find (pcache->dynamic_map, r)) != RADIX_NO_VALUE) {
+ if ((r =
+ radix32tree_find (pcache->dynamic_map,
+ r)) != RADIX_NO_VALUE) {
t = (GList *)((gpointer)r);
t = g_list_prepend (t, item);
/* Replace pointers in radix tree and in destructor function */
- rspamd_mempool_replace_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
- rr = radix32tree_replace (pcache->dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
+ rspamd_mempool_replace_destructor (dynamic_pool,
+ (rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
+ rr =
+ radix32tree_replace (pcache->dynamic_map,
+ ntohl (it->addr.s_addr), mask, (uintptr_t)t);
if (rr == -1) {
- msg_warn ("cannot replace ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
+ msg_warn ("cannot replace ip to tree: %s, mask %X",
+ inet_ntoa (it->addr),
+ mask);
}
}
else {
t = g_list_prepend (NULL, item);
- rspamd_mempool_add_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, t);
- rr = radix32tree_insert (pcache->dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
+ rspamd_mempool_add_destructor (dynamic_pool,
+ (rspamd_mempool_destruct_t)g_list_free, t);
+ rr =
+ radix32tree_insert (pcache->dynamic_map,
+ ntohl (it->addr.s_addr), mask, (uintptr_t)t);
if (rr == -1) {
- msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
+ msg_warn ("cannot insert ip to tree: %s, mask %X",
+ inet_ntoa (it->addr),
+ mask);
}
else if (rr == 1) {
- msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (it->addr), mask);
+ msg_warn ("ip %s, mask %X, value already exists",
+ inet_ntoa (it->addr),
+ mask);
}
}
}
static void
free_cache (gpointer arg)
{
- struct symbols_cache *cache = arg;
-
+ struct symbols_cache *cache = arg;
+
if (cache->map != NULL) {
unmap_cache_file (cache);
}
}
gboolean
-init_symbols_cache (rspamd_mempool_t * pool, struct symbols_cache *cache, struct rspamd_config *cfg,
- const gchar *filename, gboolean ignore_checksum)
+init_symbols_cache (rspamd_mempool_t * pool,
+ struct symbols_cache *cache,
+ struct rspamd_config *cfg,
+ const gchar *filename,
+ gboolean ignore_checksum)
{
- struct stat st;
- gint fd;
- GChecksum *cksum;
- u_char *mem_sum, *file_sum;
- gsize cklen;
- gboolean res;
+ struct stat st;
+ gint fd;
+ GChecksum *cksum;
+ u_char *mem_sum, *file_sum;
+ gsize cklen;
+ gboolean res;
if (cache == NULL) {
return FALSE;
post_cache_init (cache);
return TRUE;
}
-
+
/* First of all try to stat file */
if (stat (filename, &st) == -1) {
/* Check errno */
if (errno == ENOENT) {
/* Try to create file */
- if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
- msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
+ if ((fd =
+ open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR |
+ S_IRUSR)) == -1) {
+ msg_info ("cannot create file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
return FALSE;
}
else {
}
}
else {
- msg_info ("cannot stat file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot stat file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
return FALSE;
}
}
else {
if ((fd = open (filename, O_RDWR)) == -1) {
- msg_info ("cannot open file %s, error %d, %s", filename, errno, strerror (errno));
+ msg_info ("cannot open file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
return FALSE;
}
}
if (errno == EINVAL) {
/* Try to create file */
msg_info ("recreate cache file");
- if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
- msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
+ if ((fd =
+ open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR |
+ S_IRUSR)) == -1) {
+ msg_info ("cannot create file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
return FALSE;
}
else {
close (fd);
g_free (mem_sum);
g_checksum_free (cksum);
- msg_err ("cannot seek to read checksum, %d, %s", errno, strerror (errno));
+ msg_err ("cannot seek to read checksum, %d, %s", errno,
+ strerror (errno));
return FALSE;
}
file_sum = g_malloc (cklen);
g_checksum_free (cksum);
msg_info ("checksum mismatch, recreating file");
/* Reopen with rw permissions */
- if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
- msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
+ if ((fd =
+ open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR |
+ S_IRUSR)) == -1) {
+ msg_info ("cannot create file %s, error %d, %s",
+ filename,
+ errno,
+ strerror (errno));
return FALSE;
}
else {
/* MMap cache file and copy saved_cache structures */
res = mmap_cache_file (cache, fd, pool);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t)free_cache, cache);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t)free_cache,
+ cache);
return res;
}
/* TODO: radix doesn't support ipv6 addrs */
return NULL;
#else
- GList *res = NULL;
- uintptr_t r;
+ GList *res = NULL;
+ uintptr_t r;
if (cache->dynamic_map != NULL && task->from_addr.s_addr != INADDR_NONE) {
- if ((r = radix32tree_find (cache->dynamic_map, ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
+ if ((r =
+ radix32tree_find (cache->dynamic_map,
+ ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
res = (GList *)((gpointer)r);
return res;
}
}
static gboolean
-check_negative_dynamic_item (struct rspamd_task *task, struct symbols_cache *cache, struct cache_item *item)
+check_negative_dynamic_item (struct rspamd_task *task,
+ struct symbols_cache *cache,
+ struct cache_item *item)
{
#ifdef HAVE_INET_PTON
/* TODO: radix doesn't support ipv6 addrs */
return FALSE;
#else
- GList *res = NULL;
- uintptr_t r;
-
- if (cache->negative_dynamic_map != NULL && task->from_addr.s_addr != INADDR_NONE) {
- if ((r = radix32tree_find (cache->negative_dynamic_map, ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
+ GList *res = NULL;
+ uintptr_t r;
+
+ if (cache->negative_dynamic_map != NULL && task->from_addr.s_addr !=
+ INADDR_NONE) {
+ if ((r =
+ radix32tree_find (cache->negative_dynamic_map,
+ ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
res = (GList *)((gpointer)r);
while (res) {
if (res->data == (gpointer)item) {
static gboolean
check_debug_symbol (struct rspamd_config *cfg, const gchar *symbol)
{
- GList *cur;
+ GList *cur;
cur = cfg->debug_symbols;
while (cur) {
}
gboolean
-validate_cache (struct symbols_cache *cache, struct rspamd_config *cfg, gboolean strict)
+validate_cache (struct symbols_cache *cache,
+ struct rspamd_config *cfg,
+ gboolean strict)
{
- struct cache_item *item;
- GList *cur, *p, *metric_symbols;
- gboolean res;
+ struct cache_item *item;
+ GList *cur, *p, *metric_symbols;
+ gboolean res;
if (cache == NULL) {
msg_err ("empty cache is invalid");
while (cur) {
item = cur->data;
if (!item->is_callback) {
- if (g_hash_table_lookup (cfg->metrics_symbols, item->s->symbol) == NULL) {
+ if (g_hash_table_lookup (cfg->metrics_symbols,
+ item->s->symbol) == NULL) {
if (strict) {
- msg_warn ("no weight registered for symbol %s", item->s->symbol);
+ msg_warn ("no weight registered for symbol %s",
+ item->s->symbol);
return FALSE;
}
else {
- msg_info ("no weight registered for symbol %s", item->s->symbol);
+ msg_info ("no weight registered for symbol %s",
+ item->s->symbol);
}
}
}
while (cur) {
item = cur->data;
if (!item->is_callback) {
- if (g_hash_table_lookup (cfg->metrics_symbols, item->s->symbol) == NULL) {
+ if (g_hash_table_lookup (cfg->metrics_symbols,
+ item->s->symbol) == NULL) {
if (strict) {
- msg_warn ("no weight registered for symbol %s", item->s->symbol);
+ msg_warn ("no weight registered for symbol %s",
+ item->s->symbol);
return FALSE;
}
else {
- msg_info ("no weight registered for symbol %s", item->s->symbol);
+ msg_info ("no weight registered for symbol %s",
+ item->s->symbol);
}
}
}
}
}
if (!res) {
- msg_warn ("symbol '%s' is registered in metric but not found in cache", cur->data);
+ msg_warn (
+ "symbol '%s' is registered in metric but not found in cache",
+ cur->data);
if (strict) {
return FALSE;
}
/* Now adjust symbol weights according to default metric */
if (cfg->default_metric != NULL) {
- g_hash_table_foreach (cfg->default_metric->symbols, rspamd_symbols_cache_metric_cb, cache);
+ g_hash_table_foreach (cfg->default_metric->symbols,
+ rspamd_symbols_cache_metric_cb,
+ cache);
/* Resort caches */
- cache->negative_items = g_list_sort (cache->negative_items, cache_logic_cmp);
- cache->static_items = g_list_sort (cache->static_items, cache_logic_cmp);
+ cache->negative_items = g_list_sort (cache->negative_items,
+ cache_logic_cmp);
+ cache->static_items =
+ g_list_sort (cache->static_items, cache_logic_cmp);
}
return TRUE;
};
gboolean
-call_symbol_callback (struct rspamd_task * task, struct symbols_cache * cache, gpointer *save)
+call_symbol_callback (struct rspamd_task * task,
+ struct symbols_cache * cache,
+ gpointer *save)
{
#ifdef HAVE_CLOCK_GETTIME
- struct timespec ts1, ts2;
+ struct timespec ts1, ts2;
#else
- struct timeval tv1, tv2;
+ struct timeval tv1, tv2;
#endif
- guint64 diff;
- struct cache_item *item = NULL;
- struct symbol_callback_data *s = *save;
+ guint64 diff;
+ struct cache_item *item = NULL;
+ struct symbol_callback_data *s = *save;
if (s == NULL) {
if (cache == NULL) {
post_cache_init (cache);
rspamd_mempool_wunlock_rwlock (cache->lock);
}
- s = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct symbol_callback_data));
+ s =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (struct symbol_callback_data));
*save = s;
if (cache->negative_items != NULL) {
s->list_pointer = g_list_first (cache->negative_items);
s->saved_item = s->list_pointer->data;
s->state = CACHE_STATE_NEGATIVE;
}
- else if ((s->list_pointer = check_dynamic_item (task, cache)) || cache->dynamic_items != NULL) {
+ else if ((s->list_pointer =
+ check_dynamic_item (task, cache)) || cache->dynamic_items != NULL) {
if (s->list_pointer == NULL) {
s->list_pointer = g_list_first (cache->dynamic_items);
s->saved_item = s->list_pointer->data;
return FALSE;
}
switch (s->state) {
- case CACHE_STATE_NEGATIVE:
- s->list_pointer = g_list_next (s->list_pointer);
- if (s->list_pointer == NULL) {
- if ((s->list_pointer = check_dynamic_item (task, cache)) || cache->dynamic_items != NULL) {
- if (s->list_pointer == NULL) {
- s->list_pointer = g_list_first (cache->dynamic_items);
- s->saved_item = s->list_pointer->data;
- s->state = CACHE_STATE_DYNAMIC;
- }
- else {
- s->saved_item = s->list_pointer->data;
- s->state = CACHE_STATE_DYNAMIC_MAP;
- }
+ case CACHE_STATE_NEGATIVE:
+ s->list_pointer = g_list_next (s->list_pointer);
+ if (s->list_pointer == NULL) {
+ if ((s->list_pointer =
+ check_dynamic_item (task,
+ cache)) || cache->dynamic_items != NULL) {
+ if (s->list_pointer == NULL) {
+ s->list_pointer = g_list_first (cache->dynamic_items);
+ s->saved_item = s->list_pointer->data;
+ s->state = CACHE_STATE_DYNAMIC;
}
else {
- s->state = CACHE_STATE_STATIC;
- s->list_pointer = g_list_first (cache->static_items);
- if (s->list_pointer) {
- s->saved_item = s->list_pointer->data;
- }
- else {
- return FALSE;
- }
+ s->saved_item = s->list_pointer->data;
+ s->state = CACHE_STATE_DYNAMIC_MAP;
}
}
else {
- s->saved_item = s->list_pointer->data;
- }
- item = s->saved_item;
- break;
- case CACHE_STATE_DYNAMIC_MAP:
- s->list_pointer = g_list_next (s->list_pointer);
- if (s->list_pointer == NULL) {
- s->list_pointer = g_list_first (cache->dynamic_items);
+ s->state = CACHE_STATE_STATIC;
+ s->list_pointer = g_list_first (cache->static_items);
if (s->list_pointer) {
s->saved_item = s->list_pointer->data;
- s->state = CACHE_STATE_DYNAMIC;
}
else {
- s->state = CACHE_STATE_STATIC;
- s->list_pointer = g_list_first (cache->static_items);
- if (s->list_pointer) {
- s->saved_item = s->list_pointer->data;
- }
- else {
- return FALSE;
- }
+ return FALSE;
}
}
- else {
+ }
+ else {
+ s->saved_item = s->list_pointer->data;
+ }
+ item = s->saved_item;
+ break;
+ case CACHE_STATE_DYNAMIC_MAP:
+ s->list_pointer = g_list_next (s->list_pointer);
+ if (s->list_pointer == NULL) {
+ s->list_pointer = g_list_first (cache->dynamic_items);
+ if (s->list_pointer) {
s->saved_item = s->list_pointer->data;
+ s->state = CACHE_STATE_DYNAMIC;
}
- item = s->saved_item;
- break;
- case CACHE_STATE_DYNAMIC:
- s->list_pointer = g_list_next (s->list_pointer);
- if (s->list_pointer == NULL) {
+ else {
s->state = CACHE_STATE_STATIC;
s->list_pointer = g_list_first (cache->static_items);
if (s->list_pointer) {
return FALSE;
}
}
- else {
- s->saved_item = s->list_pointer->data;
- /* Skip items that are in negative map */
- while (s->list_pointer != NULL && check_negative_dynamic_item (task, cache, s->saved_item)) {
- s->list_pointer = g_list_next (s->list_pointer);
- if (s->list_pointer != NULL) {
- s->saved_item = s->list_pointer->data;
- }
- }
- if (s->list_pointer == NULL) {
- s->state = CACHE_STATE_STATIC;
- s->list_pointer = g_list_first (cache->static_items);
- if (s->list_pointer) {
- s->saved_item = s->list_pointer->data;
- }
- else {
- return FALSE;
- }
- }
- }
- item = s->saved_item;
- break;
- case CACHE_STATE_STATIC:
- /* Next pointer */
- s->list_pointer = g_list_next (s->list_pointer);
+ }
+ else {
+ s->saved_item = s->list_pointer->data;
+ }
+ item = s->saved_item;
+ break;
+ case CACHE_STATE_DYNAMIC:
+ s->list_pointer = g_list_next (s->list_pointer);
+ if (s->list_pointer == NULL) {
+ s->state = CACHE_STATE_STATIC;
+ s->list_pointer = g_list_first (cache->static_items);
if (s->list_pointer) {
s->saved_item = s->list_pointer->data;
}
else {
return FALSE;
}
- item = s->saved_item;
- break;
+ }
+ else {
+ s->saved_item = s->list_pointer->data;
+ /* Skip items that are in negative map */
+ while (s->list_pointer != NULL &&
+ check_negative_dynamic_item (task, cache, s->saved_item)) {
+ s->list_pointer = g_list_next (s->list_pointer);
+ if (s->list_pointer != NULL) {
+ s->saved_item = s->list_pointer->data;
+ }
+ }
+ if (s->list_pointer == NULL) {
+ s->state = CACHE_STATE_STATIC;
+ s->list_pointer = g_list_first (cache->static_items);
+ if (s->list_pointer) {
+ s->saved_item = s->list_pointer->data;
+ }
+ else {
+ return FALSE;
+ }
+ }
+ }
+ item = s->saved_item;
+ break;
+ case CACHE_STATE_STATIC:
+ /* Next pointer */
+ s->list_pointer = g_list_next (s->list_pointer);
+ if (s->list_pointer) {
+ s->saved_item = s->list_pointer->data;
+ }
+ else {
+ return FALSE;
+ }
+ item = s->saved_item;
+ break;
}
}
if (!item) {
# ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts1);
# elif defined(HAVE_CLOCK_VIRTUAL)
- clock_gettime (CLOCK_VIRTUAL, &ts1);
+ clock_gettime (CLOCK_VIRTUAL, &ts1);
# else
- clock_gettime (CLOCK_REALTIME, &ts1);
+ clock_gettime (CLOCK_REALTIME, &ts1);
# endif
#else
if (gettimeofday (&tv1, NULL) == -1) {
# ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts2);
# elif defined(HAVE_CLOCK_VIRTUAL)
- clock_gettime (CLOCK_VIRTUAL, &ts2);
+ clock_gettime (CLOCK_VIRTUAL, &ts2);
# else
- clock_gettime (CLOCK_REALTIME, &ts2);
+ clock_gettime (CLOCK_REALTIME, &ts2);
# endif
#else
if (gettimeofday (&tv2, NULL) == -1) {
#endif
#ifdef HAVE_CLOCK_GETTIME
- diff = (ts2.tv_sec - ts1.tv_sec) * 1000000 + (ts2.tv_nsec - ts1.tv_nsec) / 1000;
+ diff =
+ (ts2.tv_sec -
+ ts1.tv_sec) * 1000000 + (ts2.tv_nsec - ts1.tv_nsec) / 1000;
#else
- diff = (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
+ diff =
+ (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
#endif
item->s->avg_time = rspamd_set_counter (item->s->symbol, diff);
}
struct dynamic_map_item *networks;
guint32 networks_number;
gboolean is_dynamic;
-
+
/* Callback data */
symbol_func_t func;
gpointer user_data;
/* Items that have negative weights */
GList *negative_items;
-
+
/* Radix map of dynamic rules with ip mappings */
radix_tree_t *dynamic_map;
radix_tree_t *negative_dynamic_map;
/**
* Load symbols cache from file, must be called _after_ init_symbols_cache
*/
-gboolean init_symbols_cache (rspamd_mempool_t *pool, struct symbols_cache *cache, struct rspamd_config *cfg,
- const gchar *filename, gboolean ignore_checksum);
+gboolean init_symbols_cache (rspamd_mempool_t *pool,
+ struct symbols_cache *cache,
+ struct rspamd_config *cfg,
+ const gchar *filename,
+ gboolean ignore_checksum);
/**
* Register function for symbols parsing
* @param func pointer to handler
* @param user_data pointer to user_data
*/
-void register_symbol (struct symbols_cache **cache, const gchar *name, double weight,
- symbol_func_t func, gpointer user_data);
+void register_symbol (struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ symbol_func_t func,
+ gpointer user_data);
/**
* Register virtual symbol
* @param name name of symbol
*/
-void register_virtual_symbol (struct symbols_cache **cache, const gchar *name, double weight);
+void register_virtual_symbol (struct symbols_cache **cache,
+ const gchar *name,
+ double weight);
/**
* Register callback function for symbols parsing
* @param func pointer to handler
* @param user_data pointer to user_data
*/
-void register_callback_symbol (struct symbols_cache **cache, const gchar *name, double weight,
- symbol_func_t func, gpointer user_data);
+void register_callback_symbol (struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ symbol_func_t func,
+ gpointer user_data);
/**
* Register function for symbols parsing with strict priority
* @param func pointer to handler
* @param user_data pointer to user_data
*/
-void register_callback_symbol_priority (struct symbols_cache **cache, const gchar *name, double weight,
- gint priority, symbol_func_t func, gpointer user_data);
+void register_callback_symbol_priority (struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ gint priority,
+ symbol_func_t func,
+ gpointer user_data);
/**
* Register function for dynamic symbols parsing
* @param func pointer to handler
* @param user_data pointer to user_data
*/
-void register_dynamic_symbol (rspamd_mempool_t *pool, struct symbols_cache **cache, const gchar *name,
- double weight, symbol_func_t func,
- gpointer user_data, GList *networks);
+void register_dynamic_symbol (rspamd_mempool_t *pool,
+ struct symbols_cache **cache,
+ const gchar *name,
+ double weight,
+ symbol_func_t func,
+ gpointer user_data,
+ GList *networks);
/**
* Call function for cached symbol using saved callback
* @param cache symbols cache
* @param saved_item pointer to currently saved item
*/
-gboolean call_symbol_callback (struct rspamd_task *task, struct symbols_cache *cache, gpointer *save);
+gboolean call_symbol_callback (struct rspamd_task *task,
+ struct symbols_cache *cache,
+ gpointer *save);
/**
* Remove all dynamic rules from cache
* @param cfg configuration
* @param strict do strict checks - symbols MUST be described in metrics
*/
-gboolean validate_cache (struct symbols_cache *cache, struct rspamd_config *cfg, gboolean strict);
+gboolean validate_cache (struct symbols_cache *cache,
+ struct rspamd_config *cfg,
+ gboolean strict);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "task.h"
-#include "main.h"
#include "filter.h"
-#include "protocol.h"
-#include "message.h"
#include "lua/lua_common.h"
+#include "main.h"
+#include "message.h"
+#include "protocol.h"
+#include "task.h"
/*
* Destructor for recipients list in a task
static void
rcpt_destruct (void *pointer)
{
- struct rspamd_task *task = (struct rspamd_task *) pointer;
+ struct rspamd_task *task = (struct rspamd_task *) pointer;
if (task->rcpt) {
g_list_free (task->rcpt);
/*
* Create new task
*/
-struct rspamd_task *
+struct rspamd_task *
rspamd_task_new (struct rspamd_worker *worker)
{
- struct rspamd_task *new_task;
+ struct rspamd_task *new_task;
new_task = g_slice_alloc0 (sizeof (struct rspamd_task));
# ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &new_task->ts);
# elif defined(HAVE_CLOCK_VIRTUAL)
- clock_gettime (CLOCK_VIRTUAL, &new_task->ts);
+ clock_gettime (CLOCK_VIRTUAL, &new_task->ts);
# else
- clock_gettime (CLOCK_REALTIME, &new_task->ts);
+ clock_gettime (CLOCK_REALTIME, &new_task->ts);
# endif
#endif
if (gettimeofday (&new_task->tv, NULL) == -1) {
/* Add destructor for recipients list (it would be better to use anonymous function here */
rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) rcpt_destruct, new_task);
+ (rspamd_mempool_destruct_t) rcpt_destruct, new_task);
new_task->results = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_hash_table_destroy,
- new_task->results);
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ new_task->results);
new_task->re_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_hash_table_destroy,
- new_task->re_cache);
- new_task->raw_headers = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ new_task->re_cache);
+ new_task->raw_headers = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_hash_table_destroy,
- new_task->raw_headers);
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ new_task->raw_headers);
new_task->emails = g_tree_new (compare_email_func);
rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_tree_destroy,
- new_task->emails);
+ (rspamd_mempool_destruct_t) g_tree_destroy,
+ new_task->emails);
new_task->urls = g_tree_new (compare_url_func);
rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_tree_destroy,
- new_task->urls);
+ (rspamd_mempool_destruct_t) g_tree_destroy,
+ new_task->urls);
new_task->sock = -1;
new_task->is_mime = TRUE;
new_task->is_json = TRUE;
gboolean
rspamd_task_fin (void *arg)
{
- struct rspamd_task *task = (struct rspamd_task *) arg;
+ struct rspamd_task *task = (struct rspamd_task *) arg;
gint r;
GError *err = NULL;
void
rspamd_task_restore (void *arg)
{
- struct rspamd_task *task = (struct rspamd_task *) arg;
+ struct rspamd_task *task = (struct rspamd_task *) arg;
/* Call post filters */
if (task->state == WAIT_POST_FILTER && !task->skip_extra_filters) {
void
rspamd_task_free (struct rspamd_task *task, gboolean is_soft)
{
- GList *part;
- struct mime_part *p;
+ GList *part;
+ struct mime_part *p;
if (task) {
debug_task ("free pointer %p", task);
}
}
-void rspamd_task_free_hard (gpointer ud)
+void
+rspamd_task_free_hard (gpointer ud)
{
struct rspamd_task *task = ud;
rspamd_task_free (task, FALSE);
}
-void rspamd_task_free_soft (gpointer ud)
+void
+rspamd_task_free_soft (gpointer ud)
{
struct rspamd_task *task = ud;
gboolean
rspamd_task_process (struct rspamd_task *task,
- struct rspamd_http_message *msg, GThreadPool *classify_pool,
- gboolean process_extra_filters)
+ struct rspamd_http_message *msg, GThreadPool *classify_pool,
+ gboolean process_extra_filters)
{
gint r;
GError *err = NULL;
#define TASK_H_
#include "config.h"
-#include "http.h"
+#include "dns.h"
#include "events.h"
-#include "util.h"
+#include "http.h"
#include "mem_pool.h"
-#include "dns.h"
+#include "util.h"
enum rspamd_command {
CMD_CHECK,
* Worker task structure
*/
struct rspamd_task {
- struct rspamd_worker *worker; /**< pointer to worker object */
+ struct rspamd_worker *worker; /**< pointer to worker object */
enum {
READ_MESSAGE,
WAIT_PRE_FILTER,
WAIT_POST_FILTER,
WRITE_REPLY,
CLOSING_CONNECTION
- } state; /**< current session state */
- enum rspamd_command cmd; /**< command */
- struct custom_command *custom_cmd; /**< custom command if any */
- gint sock; /**< socket descriptor */
+ } state; /**< current session state */
+ enum rspamd_command cmd; /**< command */
+ struct custom_command *custom_cmd; /**< custom command if any */
+ gint sock; /**< socket descriptor */
gboolean is_mime; /**< if this task is mime task */
- gboolean is_json; /**< output is JSON */
- gboolean skip_extra_filters; /**< skip pre and post filters */
+ gboolean is_json; /**< output is JSON */
+ gboolean skip_extra_filters; /**< skip pre and post filters */
gboolean is_skipped; /**< whether message was skipped by configuration */
- gchar *helo; /**< helo header value */
- gchar *from; /**< from header value */
- gchar *queue_id; /**< queue id if specified */
- const gchar *message_id; /**< message id */
- GList *rcpt; /**< recipients list */
- guint nrcpt; /**< number of recipients */
- rspamd_inet_addr_t from_addr; /**< from addr for a task */
- rspamd_inet_addr_t client_addr; /**< address of connected socket */
- gchar *deliver_to; /**< address to deliver */
- gchar *user; /**< user to deliver */
- gchar *subject; /**< subject (for non-mime) */
- gchar *hostname; /**< hostname reported by MTA */
- GString *msg; /**< message buffer */
- struct rspamd_http_connection *http_conn; /**< HTTP server connection */
- struct rspamd_async_session* s; /**< async session object */
- gint parts_count; /**< mime parts count */
- GMimeMessage *message; /**< message, parsed with GMime */
- GMimeObject *parser_parent_part; /**< current parent part */
- InternetAddressList *rcpts; /**< list of all recipients */
- GList *parts; /**< list of parsed parts */
- GList *text_parts; /**< list of text parts */
- gchar *raw_headers_str; /**< list of raw headers */
- GList *received; /**< list of received headers */
- GTree *urls; /**< list of parsed urls */
- GTree *emails; /**< list of parsed emails */
- GList *images; /**< list of images */
- GHashTable *raw_headers; /**< list of raw headers */
- GHashTable *results; /**< hash table of metric_result indexed by
- * metric's name */
- GHashTable *tokens; /**< hash table of tokens indexed by tokenizer
- * pointer */
- GList *messages; /**< list of messages that would be reported */
- GHashTable *re_cache; /**< cache for matched or not matched regexps */
- struct rspamd_config *cfg; /**< pointer to config object */
- gchar *last_error; /**< last error */
- gint error_code; /**< code of last error */
- rspamd_mempool_t *task_pool; /**< memory pool for task */
+ gchar *helo; /**< helo header value */
+ gchar *from; /**< from header value */
+ gchar *queue_id; /**< queue id if specified */
+ const gchar *message_id; /**< message id */
+ GList *rcpt; /**< recipients list */
+ guint nrcpt; /**< number of recipients */
+ rspamd_inet_addr_t from_addr; /**< from addr for a task */
+ rspamd_inet_addr_t client_addr; /**< address of connected socket */
+ gchar *deliver_to; /**< address to deliver */
+ gchar *user; /**< user to deliver */
+ gchar *subject; /**< subject (for non-mime) */
+ gchar *hostname; /**< hostname reported by MTA */
+ GString *msg; /**< message buffer */
+ struct rspamd_http_connection *http_conn; /**< HTTP server connection */
+ struct rspamd_async_session * s; /**< async session object */
+ gint parts_count; /**< mime parts count */
+ GMimeMessage *message; /**< message, parsed with GMime */
+ GMimeObject *parser_parent_part; /**< current parent part */
+ InternetAddressList *rcpts; /**< list of all recipients */
+ GList *parts; /**< list of parsed parts */
+ GList *text_parts; /**< list of text parts */
+ gchar *raw_headers_str; /**< list of raw headers */
+ GList *received; /**< list of received headers */
+ GTree *urls; /**< list of parsed urls */
+ GTree *emails; /**< list of parsed emails */
+ GList *images; /**< list of images */
+ GHashTable *raw_headers; /**< list of raw headers */
+ GHashTable *results; /**< hash table of metric_result indexed by
+ * metric's name */
+ GHashTable *tokens; /**< hash table of tokens indexed by tokenizer
+ * pointer */
+ GList *messages; /**< list of messages that would be reported */
+ GHashTable *re_cache; /**< cache for matched or not matched regexps */
+ struct rspamd_config *cfg; /**< pointer to config object */
+ gchar *last_error; /**< last error */
+ gint error_code; /**< code of last error */
+ rspamd_mempool_t *task_pool; /**< memory pool for task */
#ifdef HAVE_CLOCK_GETTIME
- struct timespec ts; /**< time of connection */
+ struct timespec ts; /**< time of connection */
#endif
- struct timeval tv; /**< time of connection */
- guint32 scan_milliseconds; /**< how much milliseconds passed */
- gboolean pass_all_filters; /**< pass task throught every rule */
- gboolean no_log; /**< do not log or write this task to the history */
- guint32 parser_recursion; /**< for avoiding recursion stack overflow */
- gboolean (*fin_callback)(void *arg); /**< calback for filters finalizing */
- void *fin_arg; /**< argument for fin callback */
+ struct timeval tv; /**< time of connection */
+ guint32 scan_milliseconds; /**< how much milliseconds passed */
+ gboolean pass_all_filters; /**< pass task throught every rule */
+ gboolean no_log; /**< do not log or write this task to the history */
+ guint32 parser_recursion; /**< for avoiding recursion stack overflow */
+ gboolean (*fin_callback)(void *arg); /**< calback for filters finalizing */
+ void *fin_arg; /**< argument for fin callback */
- guint32 dns_requests; /**< number of DNS requests per this task */
+ guint32 dns_requests; /**< number of DNS requests per this task */
- struct rspamd_dns_resolver *resolver; /**< DNS resolver */
- struct event_base *ev_base; /**< Event base */
+ struct rspamd_dns_resolver *resolver; /**< DNS resolver */
+ struct event_base *ev_base; /**< Event base */
- GThreadPool *classify_pool; /**< A pool of classify threads */
+ GThreadPool *classify_pool; /**< A pool of classify threads */
struct {
- enum rspamd_metric_action action; /**< Action of pre filters */
- gchar *str; /**< String describing action */
- } pre_result; /**< Result of pre-filters */
+ enum rspamd_metric_action action; /**< Action of pre filters */
+ gchar *str; /**< String describing action */
+ } pre_result; /**< Result of pre-filters */
- ucl_object_t *settings; /**< Settings applied to task */
+ ucl_object_t *settings; /**< Settings applied to task */
};
/**
* Construct new task for worker
*/
-struct rspamd_task* rspamd_task_new (struct rspamd_worker *worker);
+struct rspamd_task * rspamd_task_new (struct rspamd_worker *worker);
/**
* Destroy task object and remove its IO dispatcher if it exists
*/
* @return task has been successfully parsed and processed
*/
gboolean rspamd_task_process (struct rspamd_task *task,
- struct rspamd_http_message *msg, GThreadPool *classify_pool,
- gboolean process_extra_filters);
+ struct rspamd_http_message *msg, GThreadPool *classify_pool,
+ gboolean process_extra_filters);
#endif /* TASK_H_ */
*/
#include "config.h"
-#include "url.h"
-#include "util.h"
#include "fstring.h"
#include "main.h"
#include "message.h"
#include "trie.h"
+#include "url.h"
+#include "util.h"
#define POST_CHAR 1
#define POST_CHAR_S "\001"
#define HIGHEST_PORT 65535
#define uri_port_is_valid(port) \
- (LOWEST_PORT <= (port) && (port) <= HIGHEST_PORT)
+ (LOWEST_PORT <= (port) && (port) <= HIGHEST_PORT)
struct _proto {
- guchar *name;
- gint port;
- uintptr_t *unused;
- guint need_slashes:1;
- guint need_slash_after_host:1;
- guint free_syntax:1;
- guint need_ssl:1;
+ guchar *name;
+ gint port;
+ uintptr_t *unused;
+ guint need_slashes : 1;
+ guint need_slash_after_host : 1;
+ guint free_syntax : 1;
+ guint need_ssl : 1;
};
typedef struct url_match_s {
struct url_matcher {
const gchar *pattern;
const gchar *prefix;
- gboolean (*start)(const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
- gboolean (*end)(const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+ gboolean (*start)(const gchar *begin, const gchar *end, const gchar *pos,
+ url_match_t *match);
+ gboolean (*end)(const gchar *begin, const gchar *end, const gchar *pos,
+ url_match_t *match);
gint flags;
};
-static gboolean url_file_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-static gboolean url_file_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-
-static gboolean url_web_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-static gboolean url_web_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-
-static gboolean url_tld_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-static gboolean url_tld_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-
-static gboolean url_email_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
-static gboolean url_email_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+static gboolean url_file_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+static gboolean url_file_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+
+static gboolean url_web_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+static gboolean url_web_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+
+static gboolean url_tld_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+static gboolean url_tld_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+
+static gboolean url_email_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
+static gboolean url_email_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match);
struct url_matcher matchers[] = {
- /* Common prefixes */
- { "file://", "", url_file_start, url_file_end, 0 },
- { "ftp://", "", url_web_start, url_web_end, 0 },
- { "sftp://", "", url_web_start, url_web_end, 0 },
- { "http://", "", url_web_start, url_web_end, 0 },
- { "https://", "", url_web_start, url_web_end, 0 },
- { "news://", "", url_web_start, url_web_end, 0 },
- { "nntp://", "", url_web_start, url_web_end, 0 },
- { "telnet://", "", url_web_start, url_web_end, 0 },
- { "webcal://", "", url_web_start, url_web_end, 0 },
- { "mailto://", "", url_email_start, url_email_end, 0 },
- { "callto://", "", url_web_start, url_web_end, 0 },
- { "h323:", "", url_web_start, url_web_end, 0 },
- { "sip:", "", url_web_start, url_web_end, 0 },
- { "www.", "http://", url_web_start, url_web_end, 0 },
- { "ftp.", "ftp://", url_web_start, url_web_end, URL_FLAG_NOHTML },
- /* TLD domains parts */
- { ".ac", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ad", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ae", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".aero", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".af", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ag", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ai", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".al", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".am", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".an", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ao", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".aq", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ar", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".arpa", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".as", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".asia", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".at", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".au", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".aw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ax", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".az", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ba", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bb", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bd", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".be", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bh", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bi", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".biz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bj", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bo", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".br", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bs", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bv", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".by", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".bz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ca", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cat", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cd", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ch", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ci", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ck", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cl", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".co", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".com", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".coop", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cv", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cx", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cy", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".cz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".de", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".dj", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".dk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".dm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".do", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".dz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ec", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".edu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ee", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".eg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".er", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".es", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".et", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".eu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".fi", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".fj", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".fk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".fm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".fo", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".fr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ga", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gb", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gd", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ge", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gh", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gi", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gl", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gov", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gp", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gq", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gs", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".gy", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".hk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".hm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".hn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".hr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ht", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".hu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".id", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ie", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".il", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".im", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".in", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".info", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".int", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".io", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".iq", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ir", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".is", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".it", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".je", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".jm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".jo", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".jobs", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".jp", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ke", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kh", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ki", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".km", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kp", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ky", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".kz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".la", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lb", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".li", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ls", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".lv", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ly", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ma", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".md", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".me", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mh", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mil", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ml", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mo", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mobi", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mp", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mq", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ms", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".museum", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mv", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mx", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".my", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".mz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".na", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".name", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".nc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ne", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".net", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".nf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ng", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ni", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".nl", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".no", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".np", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".nr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".nu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".nz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".om", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".org", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pa", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pe", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ph", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pl", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pro", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ps", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".pw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".py", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".qa", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".re", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ro", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".rs", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ru", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".rw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sa", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sb", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sd", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".se", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sh", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".si", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sj", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sl", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".so", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".st", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".su", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sv", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sx", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sy", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".sz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".td", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tel", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".th", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tj", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tl", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".to", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tp", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tr", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".travel", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tv", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".tz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ua", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ug", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".uk", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".us", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".uy", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".uz", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".va", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".vc", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ve", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".vg", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".vi", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".vn", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".vu", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".wf", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ws", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".xxx", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".ye", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".yt", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".za", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".zm", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- { ".zw", "http://", url_tld_start, url_tld_end, URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
- /* Likely emails */
- { "@", "mailto://",url_email_start, url_email_end, URL_FLAG_NOHTML }
+ /* Common prefixes */
+ { "file://", "", url_file_start, url_file_end,
+ 0 },
+ { "ftp://", "", url_web_start, url_web_end,
+ 0 },
+ { "sftp://", "", url_web_start, url_web_end,
+ 0 },
+ { "http://", "", url_web_start, url_web_end,
+ 0 },
+ { "https://", "", url_web_start, url_web_end,
+ 0 },
+ { "news://", "", url_web_start, url_web_end,
+ 0 },
+ { "nntp://", "", url_web_start, url_web_end,
+ 0 },
+ { "telnet://", "", url_web_start, url_web_end,
+ 0 },
+ { "webcal://", "", url_web_start, url_web_end,
+ 0 },
+ { "mailto://", "", url_email_start, url_email_end,
+ 0 },
+ { "callto://", "", url_web_start, url_web_end,
+ 0 },
+ { "h323:", "", url_web_start, url_web_end,
+ 0 },
+ { "sip:", "", url_web_start, url_web_end,
+ 0 },
+ { "www.", "http://", url_web_start, url_web_end,
+ 0 },
+ { "ftp.", "ftp://", url_web_start, url_web_end,
+ URL_FLAG_NOHTML },
+ /* TLD domains parts */
+ { ".ac", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ad", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ae", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".aero", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".af", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ag", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ai", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".al", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".am", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".an", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ao", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".aq", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ar", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".arpa", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".as", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".asia", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".at", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".au", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".aw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ax", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".az", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ba", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bb", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bd", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".be", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bh", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bi", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".biz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bj", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bo", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".br", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bs", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bv", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".by", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".bz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ca", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cat", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cd", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ch", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ci", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ck", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cl", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".co", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".com", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".coop", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cv", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cx", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cy", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".cz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".de", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".dj", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".dk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".dm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".do", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".dz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ec", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".edu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ee", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".eg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".er", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".es", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".et", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".eu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".fi", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".fj", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".fk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".fm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".fo", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".fr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ga", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gb", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gd", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ge", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gh", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gi", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gl", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gov", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gp", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gq", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gs", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".gy", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".hk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".hm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".hn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".hr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ht", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".hu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".id", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ie", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".il", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".im", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".in", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".info", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".int", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".io", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".iq", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ir", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".is", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".it", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".je", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".jm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".jo", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".jobs", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".jp", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ke", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kh", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ki", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".km", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kp", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ky", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".kz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".la", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lb", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".li", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ls", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".lv", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ly", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ma", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".md", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".me", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mh", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mil", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ml", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mo", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mobi", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mp", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mq", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ms", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".museum", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mv", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mx", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".my", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".mz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".na", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".name", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".nc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ne", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".net", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".nf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ng", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ni", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".nl", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".no", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".np", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".nr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".nu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".nz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".om", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".org", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pa", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pe", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ph", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pl", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pro", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ps", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".pw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".py", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".qa", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".re", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ro", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".rs", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ru", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".rw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sa", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sb", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sd", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".se", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sh", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".si", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sj", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sl", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".so", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".st", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".su", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sv", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sx", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sy", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".sz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".td", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tel", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".th", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tj", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tl", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".to", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tp", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tr", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".travel", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tv", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".tz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ua", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ug", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".uk", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".us", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".uy", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".uz", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".va", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".vc", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ve", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".vg", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".vi", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".vn", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".vu", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".wf", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ws", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".xxx", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".ye", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".yt", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".za", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".zm", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ { ".zw", "http://", url_tld_start, url_tld_end,
+ URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+ /* Likely emails */
+ { "@", "mailto://",url_email_start, url_email_end,
+ URL_FLAG_NOHTML }
};
struct url_match_scanner {
struct url_match_scanner *url_scanner = NULL;
-static const struct _proto protocol_backends[] = {
+static const struct _proto protocol_backends[] = {
{"file", 0, NULL, 1, 0, 0, 0},
{"ftp", 21, NULL, 1, 0, 0, 0},
{"http", 80, NULL, 1, 0, 0, 0},
/* Convert an ASCII hex digit to the corresponding number between 0
and 15. H should be a hexadecimal digit that satisfies isxdigit;
otherwise, the result is undefined. */
-#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : g_ascii_toupper (h) - 'A' + 10)
+#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : g_ascii_toupper (h) - 'A' + \
+ 10)
#define X2DIGITS_TO_NUM(h1, h2) ((XDIGIT_TO_NUM (h1) << 4) + XDIGIT_TO_NUM (h2))
/* The reverse of the above: convert a number in the [0, 16) range to
the ASCII representation of the corresponding hexadecimal digit.
#define XNUM_TO_digit(x) ("0123456789abcdef"[x] + 0)
static guchar url_scanner_table[256] = {
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 1, 1, 9, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 24,128,160,128,128,128,128,128,160,160,128,128,160,192,160,160,
- 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,160,160, 32,128, 32,128,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 1, 1, 9, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 24,128,160,128,128,128,128,128,160,160,128,128,160,192,160,160,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,160,160, 32,128, 32,128,
160, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
- 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,160,160,160,128,192,
+ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,160,160,160,128,192,
128, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
- 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,128,128,128,128, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,128,128,128,128, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
enum {
- IS_CTRL = (1 << 0),
- IS_ALPHA = (1 << 1),
- IS_DIGIT = (1 << 2),
- IS_LWSP = (1 << 3),
- IS_SPACE = (1 << 4),
- IS_SPECIAL = (1 << 5),
- IS_DOMAIN = (1 << 6),
- IS_URLSAFE = (1 << 7)
+ IS_CTRL = (1 << 0),
+ IS_ALPHA = (1 << 1),
+ IS_DIGIT = (1 << 2),
+ IS_LWSP = (1 << 3),
+ IS_SPACE = (1 << 4),
+ IS_SPECIAL = (1 << 5),
+ IS_DOMAIN = (1 << 6),
+ IS_URLSAFE = (1 << 7)
};
#define is_ctrl(x) ((url_scanner_table[(guchar)(x)] & IS_CTRL) != 0)
#define is_lwsp(x) ((url_scanner_table[(guchar)(x)] & IS_LWSP) != 0)
-#define is_atom(x) ((url_scanner_table[(guchar)(x)] & (IS_SPECIAL|IS_SPACE|IS_CTRL)) == 0)
+#define is_atom(x) ((url_scanner_table[(guchar)(x)] & (IS_SPECIAL | IS_SPACE | \
+ IS_CTRL)) == 0)
#define is_alpha(x) ((url_scanner_table[(guchar)(x)] & IS_ALPHA) != 0)
#define is_digit(x) ((url_scanner_table[(guchar)(x)] & IS_DIGIT) != 0)
#define is_domain(x) ((url_scanner_table[(guchar)(x)] & IS_DOMAIN) != 0)
-#define is_urlsafe(x) ((url_scanner_table[(guchar)(x)] & (IS_ALPHA|IS_DIGIT|IS_URLSAFE)) != 0)
+#define is_urlsafe(x) ((url_scanner_table[(guchar)(x)] & (IS_ALPHA | IS_DIGIT | \
+ IS_URLSAFE)) != 0)
-const gchar *
+const gchar *
url_strerror (enum uri_errno err)
{
switch (err) {
static gint
check_uri_file (gchar *name)
{
- static const gchar chars[] = POST_CHAR_S "#?";
+ static const gchar chars[] = POST_CHAR_S "#?";
return strcspn (name, chars);
}
static gint
url_init (void)
{
- guint i;
- gchar patbuf[128];
+ guint i;
+ gchar patbuf[128];
if (url_scanner == NULL) {
url_scanner = g_malloc (sizeof (struct url_match_scanner));
url_scanner->matchers = matchers;
url_scanner->matchers_count = G_N_ELEMENTS (matchers);
url_scanner->patterns = rspamd_trie_create (TRUE);
- for (i = 0; i < url_scanner->matchers_count; i ++) {
+ for (i = 0; i < url_scanner->matchers_count; i++) {
if (matchers[i].flags & URL_FLAG_STRICT_MATCH) {
/* Insert more specific patterns */
/* some.tld/ */
- rspamd_snprintf (patbuf, sizeof (patbuf), "%s/", matchers[i].pattern);
+ rspamd_snprintf (patbuf,
+ sizeof (patbuf),
+ "%s/",
+ matchers[i].pattern);
rspamd_trie_insert (url_scanner->patterns, patbuf, i);
/* some.tld */
- rspamd_snprintf (patbuf, sizeof (patbuf), "%s ", matchers[i].pattern);
+ rspamd_snprintf (patbuf,
+ sizeof (patbuf),
+ "%s ",
+ matchers[i].pattern);
rspamd_trie_insert (url_scanner->patterns, patbuf, i);
/* some.tld: */
- rspamd_snprintf (patbuf, sizeof (patbuf), "%s:", matchers[i].pattern);
+ rspamd_snprintf (patbuf,
+ sizeof (patbuf),
+ "%s:",
+ matchers[i].pattern);
rspamd_trie_insert (url_scanner->patterns, patbuf, i);
}
else {
- rspamd_trie_insert (url_scanner->patterns, matchers[i].pattern, i);
+ rspamd_trie_insert (url_scanner->patterns,
+ matchers[i].pattern,
+ i);
}
}
}
/* These are really enum protocol values but can take on negative
* values and since 0 <= -1 for enum values it's better to use clean
* integer type. */
- gint start, end;
- enum protocol protocol;
- guchar *pname;
- gint pnamelen, minlen, compare;
+ gint start, end;
+ enum protocol protocol;
+ guchar *pname;
+ gint pnamelen, minlen, compare;
/* Almost dichotomic search is used here */
/* Starting at the HTTP entry which is the most common that will make
static gint
get_protocol_length (const gchar *url)
{
- gchar *end = (gchar *)url;
+ gchar *end = (gchar *)url;
/* Seek the end of the protocol name if any. */
/* RFC1738:
static guint
url_calculate_escaped_hostlen (gchar *host, guint hostlen)
{
- guint i, result = hostlen;
- gchar *p = host, c;
+ guint i, result = hostlen;
+ gchar *p = host, c;
for (i = 0; i < hostlen; i++, p++) {
- if (*p == '%' && g_ascii_isxdigit (*(p + 1)) && g_ascii_isxdigit (*(p + 2)) && i < hostlen - 2) {
+ if (*p == '%' && g_ascii_isxdigit (*(p + 1)) &&
+ g_ascii_isxdigit (*(p + 2)) && i < hostlen - 2) {
c = X2DIGITS_TO_NUM (*(p + 1), *(p + 2));
if (c != '\0') {
result -= 2;
static void
url_unescape (gchar *s)
{
- gchar *t = s; /* t - tortoise */
- gchar *h = s; /* h - hare */
+ gchar *t = s; /* t - tortoise */
+ gchar *h = s; /* h - hare */
for (; *h; h++, t++) {
if (*h != '%') {
- copychar:
+copychar:
*t = *h;
}
else {
- gchar c;
+ gchar c;
/* Do nothing if '%' is not followed by two hex digits. */
- if (!h[1] || !h[2] || !(g_ascii_isxdigit (h[1]) && g_ascii_isxdigit (h[2])))
+ if (!h[1] || !h[2] ||
+ !(g_ascii_isxdigit (h[1]) && g_ascii_isxdigit (h[2])))
goto copychar;
c = X2DIGITS_TO_NUM (h[1], h[2]);
/* Don't unescape %00 because there is no way to insert it
static void
url_strip (gchar *s)
{
- gchar *t = s; /* t - tortoise */
- gchar *h = s; /* h - hare */
+ gchar *t = s; /* t - tortoise */
+ gchar *h = s; /* h - hare */
while (*h) {
if (g_ascii_isgraph (*h)) {
*t = '\0';
}
-static gchar *
+static gchar *
url_escape_1 (const gchar *s, gint allow_passthrough, rspamd_mempool_t * pool)
{
- const gchar *p1;
- gchar *p2, *newstr;
- gint newlen;
- gint addition = 0;
+ const gchar *p1;
+ gchar *p2, *newstr;
+ gint newlen;
+ gint addition = 0;
for (p1 = s; *p1; p1++)
if (!is_urlsafe (*p1)) {
- addition += 2; /* Two more characters (hex digits) */
+ addition += 2; /* Two more characters (hex digits) */
}
if (!addition) {
while (*p1) {
/* Quote the characters that match the test mask. */
if (!is_urlsafe (*p1)) {
- guchar c = *p1++;
+ guchar c = *p1++;
*p2++ = '%';
*p2++ = XNUM_TO_DIGIT (c >> 4);
*p2++ = XNUM_TO_DIGIT (c & 0xf);
/* URL-escape the unsafe characters (see urlchr_table) in a given
string, returning a freshly allocated string. */
-gchar *
+gchar *
url_escape (const gchar *s, rspamd_mempool_t * pool)
{
return url_escape_1 (s, 0, pool);
return TRUE;
}
}
- else if (! is_urlsafe (*p)) {
+ else if (!is_urlsafe (*p)) {
return TRUE;
}
return FALSE;
/* Translate a %-escaped (but possibly non-conformant) input string S
into a %-escaped (and conformant) output string.
-*/
+ */
-static gchar *
+static gchar *
reencode_escapes (gchar *s, rspamd_mempool_t * pool)
{
- const gchar *p1;
- gchar *newstr, *p2;
- gint oldlen, newlen;
+ const gchar *p1;
+ gchar *newstr, *p2;
+ gint oldlen, newlen;
- gint encode_count = 0;
+ gint encode_count = 0;
/* First pass: inspect the string to see if there's anything to do,
and to calculate the new length. */
while (*p1)
if (char_needs_escaping (p1)) {
- guchar c = *p1++;
+ guchar c = *p1++;
*p2++ = '%';
*p2++ = XNUM_TO_DIGIT (c >> 4);
*p2++ = XNUM_TO_DIGIT (c & 0xf);
static void
unescape_single_char (gchar *str, gchar chr)
{
- const gchar c1 = XNUM_TO_DIGIT (chr >> 4);
- const gchar c2 = XNUM_TO_DIGIT (chr & 0xf);
- gchar *h = str; /* hare */
- gchar *t = str; /* tortoise */
+ const gchar c1 = XNUM_TO_DIGIT (chr >> 4);
+ const gchar c2 = XNUM_TO_DIGIT (chr & 0xf);
+ gchar *h = str; /* hare */
+ gchar *t = str; /* tortoise */
for (; *h; h++, t++) {
if (h[0] == '%' && h[1] == c1 && h[2] == c2) {
static gboolean
path_simplify (gchar *path)
{
- gchar *h = path; /* hare */
- gchar *t = path; /* tortoise */
- gchar *beg = path; /* boundary for backing the tortoise */
- gchar *end = path + strlen (path);
+ gchar *h = path; /* hare */
+ gchar *t = path; /* tortoise */
+ gchar *beg = path; /* boundary for backing the tortoise */
+ gchar *end = path + strlen (path);
while (h < end) {
/* Hare should be at the beginning of a path element. */
if (t > beg) {
/* Move backwards until T hits the beginning of the
previous path element or the beginning of path. */
- for (--t; t > beg && t[-1] != '/'; t--);
+ for (--t; t > beg && t[-1] != '/'; t--) ;
}
else {
/* If we're at the beginning, copy the "../" literally
h += 3;
}
else {
- regular:
+regular:
/* A regular path element. If H hasn't advanced past T,
simply skip to the next path element. Otherwise, copy
the path element until the next slash. */
enum uri_errno
parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
{
- guchar *prefix_end, *host_end, *p;
- guchar *lbracket, *rbracket;
- gint datalen, n, addrlen;
- guchar *frag_or_post, *user_end, *port_end;
+ guchar *prefix_end, *host_end, *p;
+ guchar *lbracket, *rbracket;
+ gint datalen, n, addrlen;
+ guchar *frag_or_post, *user_end, *port_end;
memset (uri, 0, sizeof (*uri));
uri->protocollen = get_protocol_length (struri (uri));
/* Assume http as default protocol */
- if (!uri->protocollen || (uri->protocol = get_protocol (struri (uri), uri->protocollen)) == PROTOCOL_UNKNOWN) {
+ if (!uri->protocollen ||
+ (uri->protocol =
+ get_protocol (struri (uri), uri->protocollen)) == PROTOCOL_UNKNOWN) {
/* Make exception for numeric urls */
p = uri->string;
while (*p && (g_ascii_isalnum (*p) || *p == ':')) {
- p ++;
+ p++;
}
if (*p == '\0') {
return URI_ERRNO_INVALID_PROTOCOL;
/* Figure out whether the protocol is known */
msg_debug ("getting protocol from url: %d", uri->protocol);
- prefix_end = struri (uri) + uri->protocollen; /* ':' */
+ prefix_end = struri (uri) + uri->protocollen; /* ':' */
/* Check if there's a digit after the protocol name. */
if (g_ascii_isdigit (*prefix_end)) {
/* Possibly skip auth part */
host_end = prefix_end + strcspn (prefix_end, "@");
- if (prefix_end + strcspn (prefix_end, "/?") > host_end && *host_end) { /* we have auth info here */
+ if (prefix_end + strcspn (prefix_end, "/?") > host_end && *host_end) { /* we have auth info here */
/* Allow '@' in the password component */
while (strcspn (host_end + 1, "@") < strcspn (host_end + 1, "/?"))
return URI_ERRNO_TRAILING_DOTS;
}
- if (*host_end == ':') { /* we have port here */
+ if (*host_end == ':') { /* we have port here */
port_end = host_end + 1 + strcspn (host_end + 1, "/");
host_end++;
host_end++;
}
- else if (get_protocol_need_slash_after_host (uri->protocol) && *host_end != '?') {
+ else if (get_protocol_need_slash_after_host (uri->protocol) && *host_end !=
+ '?') {
/* The need for slash after the host component depends on the
* need for a host component. -- The dangerous mind of Jonah */
if (!uri->hostlen)
}
convert_to_lowercase (uri->string, uri->protocollen);
- convert_to_lowercase (uri->host, uri->hostlen);
+ convert_to_lowercase (uri->host, uri->hostlen);
/* Decode %HH sequences in host name. This is important not so much
to support %HH sequences in host names (which other browser
don't), but to support binary characters (which will have been
}
static const gchar url_braces[] = {
- '(', ')' ,
- '{', '}' ,
- '[', ']' ,
- '<', '>' ,
- '|', '|' ,
- '\'', '\''
+ '(', ')',
+ '{', '}',
+ '[', ']',
+ '<', '>',
+ '|', '|',
+ '\'', '\''
};
static gboolean
}
static gboolean
-url_file_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_file_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
match->m_begin = pos;
return TRUE;
}
static gboolean
-url_file_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_file_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
- const gchar *p;
- gchar stop;
- guint i;
+ const gchar *p;
+ gchar stop;
+ guint i;
p = pos + strlen (match->pattern);
stop = *p;
if (*p == '/') {
- p ++;
+ p++;
}
for (i = 0; i < G_N_ELEMENTS (url_braces) / 2; i += 2) {
}
while (p < end && *p != stop && is_urlsafe (*p)) {
- p ++;
+ p++;
}
if (p == begin) {
}
static gboolean
-url_tld_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_tld_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
- const gchar *p = pos;
+ const gchar *p = pos;
/* Try to find the start of the url by finding any non-urlsafe character or whitespace/punctuation */
while (p >= begin) {
- if ((!is_domain (*p) && *p != '.' && *p != '/') || g_ascii_isspace (*p)) {
- p ++;
+ if ((!is_domain (*p) && *p != '.' &&
+ *p != '/') || g_ascii_isspace (*p)) {
+ p++;
if (!g_ascii_isalnum (*p)) {
/* Urls cannot start with strange symbols */
return FALSE;
/* Urls cannot contain '/' in their body */
return FALSE;
}
- p --;
+ p--;
}
return FALSE;
}
static gboolean
-url_tld_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_tld_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
- const gchar *p;
+ const gchar *p;
/* A url must be finished by tld, so it must be followed by space character */
p = pos + strlen (match->pattern);
p = match->m_begin;
/* Check common prefix */
if (g_ascii_strncasecmp (p, "http://", sizeof ("http://") - 1) == 0) {
- return url_web_end (begin, end, match->m_begin + sizeof ("http://") - 1, match);
+ return url_web_end (begin,
+ end,
+ match->m_begin + sizeof ("http://") - 1,
+ match);
}
else {
return url_web_end (begin, end, match->m_begin, match);
}
static gboolean
-url_web_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_web_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
/* Check what we have found */
- if (pos > begin && (g_ascii_strncasecmp (pos, "www", 3) == 0 || g_ascii_strncasecmp (pos, "ftp", 3) == 0)) {
+ if (pos > begin &&
+ (g_ascii_strncasecmp (pos, "www",
+ 3) == 0 || g_ascii_strncasecmp (pos, "ftp", 3) == 0)) {
if (!is_open_brace (*(pos - 1)) && !g_ascii_isspace (*(pos - 1))) {
return FALSE;
}
}
static gboolean
-url_web_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_web_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
- const gchar *p, *c;
- gchar open_brace = '\0', close_brace = '\0';
- gint brace_stack = 0;
- gboolean passwd = FALSE;
- guint port, i;
+ const gchar *p, *c;
+ gchar open_brace = '\0', close_brace = '\0';
+ gint brace_stack = 0;
+ gboolean passwd = FALSE;
+ guint port, i;
p = pos + strlen (match->pattern);
for (i = 0; i < G_N_ELEMENTS (url_braces) / 2; i += 2) {
p++;
}
- if ((p + 1) < end && *p == '.' && (is_atom (*(p + 1)) || *(p + 1) == '/')) {
+ if ((p + 1) < end && *p == '.' &&
+ (is_atom (*(p + 1)) || *(p + 1) == '/')) {
p++;
}
}
p++;
}
- if ((p + 1) < end && *p == '.' && (is_domain (*(p + 1)) || *(p + 1) == '/' || (*(p + 1) & 0x80))) {
+ if ((p + 1) < end && *p == '.' &&
+ (is_domain (*(p + 1)) || *(p + 1) == '/' ||
+ (*(p + 1) & 0x80))) {
p++;
}
}
}
}
else {
- passwd:
+passwd:
passwd = TRUE;
c = p;
break;
}
- /* we have a '/' so there could be a path - fall through */
+ /* we have a '/' so there could be a path - fall through */
case '/': /* we've detected a path component to our url */
p++;
case '?':
static gboolean
-url_email_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_email_start (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
- const gchar *p;
+ const gchar *p;
/* Check what we have found */
if (pos > begin && *pos == '@') {
/* Try to extract it with username */
p = pos - 1;
while (p > begin && (is_domain (*p) || *p == '.' || *p == '_')) {
- p --;
+ p--;
}
if (!is_domain (*p) && p != pos - 1) {
match->m_begin = p + 1;
}
static gboolean
-url_email_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
+url_email_end (const gchar *begin,
+ const gchar *end,
+ const gchar *pos,
+ url_match_t *match)
{
- const gchar *p;
- gboolean got_at = FALSE;
+ const gchar *p;
+ gboolean got_at = FALSE;
p = pos + strlen (match->pattern);
if (*pos == '@') {
}
while (p < end && (is_domain (*p) || *p == '_'
- || (*p == '@' && !got_at) ||
- (*p == '.' && p + 1 < end && is_domain (*(p + 1))))) {
+ || (*p == '@' && !got_at) ||
+ (*p == '.' && p + 1 < end && is_domain (*(p + 1))))) {
if (*p == '@') {
got_at = TRUE;
}
- p ++;
+ p++;
}
match->m_len = p - match->m_begin;
match->add_prefix = TRUE;
}
void
-url_parse_text (rspamd_mempool_t * pool, struct rspamd_task *task, struct mime_text_part *part, gboolean is_html)
+url_parse_text (rspamd_mempool_t * pool,
+ struct rspamd_task *task,
+ struct mime_text_part *part,
+ gboolean is_html)
{
- gint rc;
- gchar *url_str = NULL, *url_start, *url_end;
- struct uri *new;
- struct process_exception *ex;
- gchar *p, *end, *begin;
+ gint rc;
+ gchar *url_str = NULL, *url_start, *url_end;
+ struct uri *new;
+ struct process_exception *ex;
+ gchar *p, *end, *begin;
if (!part->orig->data || part->orig->len == 0) {
p = begin;
}
while (p < end) {
- if (url_try_text (pool, p, end - p, &url_start, &url_end, &url_str, is_html)) {
+ if (url_try_text (pool, p, end - p, &url_start, &url_end, &url_str,
+ is_html)) {
if (url_str != NULL) {
new = rspamd_mempool_alloc0 (pool, sizeof (struct uri));
- ex = rspamd_mempool_alloc0 (pool, sizeof (struct process_exception));
+ ex =
+ rspamd_mempool_alloc0 (pool,
+ sizeof (struct process_exception));
if (new != NULL) {
g_strstrip (url_str);
rc = parse_uri (new, url_str, pool);
- if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc == URI_ERRNO_NO_HOST_SLASH) &&
- new->hostlen > 0) {
+ if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES ||
+ rc == URI_ERRNO_NO_HOST_SLASH) &&
+ new->hostlen > 0) {
ex->pos = url_start - begin;
ex->len = url_end - url_start;
if (new->protocol == PROTOCOL_MAILTO) {
g_tree_insert (task->urls, new, new);
}
}
- part->urls_offset = g_list_prepend (part->urls_offset, ex);
+ part->urls_offset = g_list_prepend (
+ part->urls_offset,
+ ex);
}
else if (rc != URI_ERRNO_OK) {
- msg_info ("extract of url '%s' failed: %s", url_str, url_strerror (rc));
+ msg_info ("extract of url '%s' failed: %s",
+ url_str,
+ url_strerror (rc));
}
}
}
/* Handle offsets of this part */
if (part->urls_offset != NULL) {
part->urls_offset = g_list_reverse (part->urls_offset);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, part->urls_offset);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, part->urls_offset);
}
}
gboolean
-url_try_text (rspamd_mempool_t *pool, const gchar *begin, gsize len, gchar **start, gchar **fin, gchar **url_str, gboolean is_html)
+url_try_text (rspamd_mempool_t *pool,
+ const gchar *begin,
+ gsize len,
+ gchar **start,
+ gchar **fin,
+ gchar **url_str,
+ gboolean is_html)
{
- const gchar *end, *pos;
- gint idx, l;
- struct url_matcher *matcher;
- url_match_t m;
+ const gchar *end, *pos;
+ gint idx, l;
+ struct url_matcher *matcher;
+ url_match_t m;
end = begin + len;
if (url_init () == 0) {
- if ((pos = rspamd_trie_lookup (url_scanner->patterns, begin, len, &idx)) == NULL) {
+ if ((pos =
+ rspamd_trie_lookup (url_scanner->patterns, begin, len,
+ &idx)) == NULL) {
return FALSE;
}
else {
m.pattern = matcher->pattern;
m.prefix = matcher->prefix;
m.add_prefix = FALSE;
- if (matcher->start (begin, end, pos, &m) && matcher->end (begin, end, pos, &m)) {
+ if (matcher->start (begin, end, pos,
+ &m) && matcher->end (begin, end, pos, &m)) {
if (m.add_prefix) {
l = m.m_len + 1 + strlen (m.prefix);
*url_str = rspamd_mempool_alloc (pool, l);
- rspamd_snprintf (*url_str, l, "%s%*s", m.prefix, m.m_len, m.m_begin);
+ rspamd_snprintf (*url_str,
+ l,
+ "%s%*s",
+ m.prefix,
+ m.m_len,
+ m.m_begin);
}
else {
*url_str = rspamd_mempool_alloc (pool, m.m_len + 1);
guint fragmentlen;
/* Flags */
- gboolean ipv6; /* URI contains IPv6 host */
- gboolean form; /* URI originated from form */
+ gboolean ipv6; /* URI contains IPv6 host */
+ gboolean form; /* URI originated from form */
gboolean is_phished; /* URI maybe phishing */
};
enum uri_errno {
- URI_ERRNO_OK, /* Parsing went well */
- URI_ERRNO_EMPTY, /* The URI string was empty */
- URI_ERRNO_INVALID_PROTOCOL, /* No protocol was found */
- URI_ERRNO_NO_SLASHES, /* Slashes after protocol missing */
- URI_ERRNO_TOO_MANY_SLASHES, /* Too many slashes after protocol */
- URI_ERRNO_TRAILING_DOTS, /* '.' after host */
- URI_ERRNO_NO_HOST, /* Host part is missing */
- URI_ERRNO_NO_PORT_COLON, /* ':' after host without port */
- URI_ERRNO_NO_HOST_SLASH, /* Slash after host missing */
- URI_ERRNO_IPV6_SECURITY, /* IPv6 security bug detected */
- URI_ERRNO_INVALID_PORT, /* Port number is bad */
- URI_ERRNO_INVALID_PORT_RANGE /* Port number is not within 0-65535 */
+ URI_ERRNO_OK, /* Parsing went well */
+ URI_ERRNO_EMPTY, /* The URI string was empty */
+ URI_ERRNO_INVALID_PROTOCOL, /* No protocol was found */
+ URI_ERRNO_NO_SLASHES, /* Slashes after protocol missing */
+ URI_ERRNO_TOO_MANY_SLASHES, /* Too many slashes after protocol */
+ URI_ERRNO_TRAILING_DOTS, /* '.' after host */
+ URI_ERRNO_NO_HOST, /* Host part is missing */
+ URI_ERRNO_NO_PORT_COLON, /* ':' after host without port */
+ URI_ERRNO_NO_HOST_SLASH, /* Slash after host missing */
+ URI_ERRNO_IPV6_SECURITY, /* IPv6 security bug detected */
+ URI_ERRNO_INVALID_PORT, /* Port number is bad */
+ URI_ERRNO_INVALID_PORT_RANGE /* Port number is not within 0-65535 */
};
enum protocol {
* @param part current text part
* @param is_html turn on html euristic
*/
-void url_parse_text (rspamd_mempool_t *pool, struct rspamd_task *task, struct mime_text_part *part, gboolean is_html);
+void url_parse_text (rspamd_mempool_t *pool,
+ struct rspamd_task *task,
+ struct mime_text_part *part,
+ gboolean is_html);
/*
* Parse a single url into an uri structure
* @param uristring text form of url
* @param uri url object, must be pre allocated
*/
-enum uri_errno parse_uri(struct uri *uri, gchar *uristring, rspamd_mempool_t *pool);
+enum uri_errno parse_uri (struct uri *uri,
+ gchar *uristring,
+ rspamd_mempool_t *pool);
/*
* Try to extract url from a text
* @param url_str storage for url string(or NULL)
* @return TRUE if url is found in specified text
*/
-gboolean url_try_text (rspamd_mempool_t *pool, const gchar *begin, gsize len, gchar **start, gchar **end, gchar **url_str, gboolean is_html);
+gboolean url_try_text (rspamd_mempool_t *pool,
+ const gchar *begin,
+ gsize len,
+ gchar **start,
+ gchar **end,
+ gchar **url_str,
+ gboolean is_html);
/*
* Return text representation of url parsing error
*/
-const gchar* url_strerror (enum uri_errno err);
+const gchar * url_strerror (enum uri_errno err);
#endif
*/
#include "config.h"
+#include "lua/lua_common.h"
#include "main.h"
#include "message.h"
-#include "lua/lua_common.h"
-extern struct rspamd_main *rspamd_main;
+extern struct rspamd_main *rspamd_main;
/**
* Return worker's control structure by its type
* @param type
* @return worker's control structure or NULL
*/
-worker_t*
+worker_t *
rspamd_get_worker_by_type (GQuark type)
{
- worker_t **cur;
+ worker_t **cur;
cur = &workers[0];
while (*cur) {
if (g_quark_from_string ((*cur)->name) == type) {
return *cur;
}
- cur ++;
+ cur++;
}
return NULL;
double
rspamd_set_counter (const gchar *name, guint32 value)
{
- struct counter_data *cd;
- double alpha;
- gchar *key;
+ struct counter_data *cd;
+ double alpha;
+ gchar *key;
cd = rspamd_hash_lookup (rspamd_main->counters, (gpointer) name);
if (cd == NULL) {
- cd = rspamd_mempool_alloc_shared (rspamd_main->counters->pool, sizeof (struct counter_data));
+ cd =
+ rspamd_mempool_alloc_shared (rspamd_main->counters->pool,
+ sizeof (struct counter_data));
cd->value = value;
cd->number = 0;
key = rspamd_mempool_strdup_shared (rspamd_main->counters->pool, name);
- rspamd_hash_insert (rspamd_main->counters, (gpointer) key, (gpointer) cd);
+ rspamd_hash_insert (rspamd_main->counters, (gpointer) key,
+ (gpointer) cd);
}
else {
/* Calculate new value */
worker_sig_handler (gint signo, siginfo_t * info, void *unused)
#endif
{
- struct timeval tv;
+ struct timeval tv;
switch (signo) {
case SIGINT:
static void
worker_sigusr2_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
/* Do not accept new connections, preparing to end worker's process */
- struct timeval tv;
+ struct timeval tv;
if (!wanna_die) {
tv.tv_sec = SOFT_SHUTDOWN_TIME;
static void
worker_sigusr1_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
reopen_log (worker->srv->logger);
struct event_base *
rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
- void (*accept_handler)(int, short, void *))
+ void (*accept_handler)(int, short, void *))
{
- struct event_base *ev_base;
- struct event *accept_event;
- struct sigaction signals;
- GList *cur;
- gint listen_socket;
+ struct event_base *ev_base;
+ struct event *accept_event;
+ struct sigaction signals;
+ GList *cur;
+ gint listen_socket;
#ifdef WITH_PROFILER
- extern void _start (void), etext (void);
+ extern void _start (void), etext (void);
monstartup ((u_long) & _start, (u_long) & etext);
#endif
if (listen_socket != -1) {
accept_event = g_slice_alloc0 (sizeof (struct event));
event_set (accept_event, listen_socket, EV_READ | EV_PERSIST,
- accept_handler, worker);
+ accept_handler, worker);
event_base_set (ev_base, accept_event);
event_add (accept_event, NULL);
- worker->accept_events = g_list_prepend (worker->accept_events, accept_event);
+ worker->accept_events = g_list_prepend (worker->accept_events,
+ accept_event);
}
cur = g_list_next (cur);
}
/* SIGUSR2 handler */
signal_set (&worker->sig_ev_usr2, SIGUSR2, worker_sigusr2_handler,
- (void *) worker);
+ (void *) worker);
event_base_set (ev_base, &worker->sig_ev_usr2);
signal_add (&worker->sig_ev_usr2, NULL);
/* SIGUSR1 handler */
signal_set (&worker->sig_ev_usr1, SIGUSR1, worker_sigusr1_handler,
- (void *) worker);
+ (void *) worker);
event_base_set (ev_base, &worker->sig_ev_usr1);
signal_add (&worker->sig_ev_usr1, NULL);
void
rspamd_worker_stop_accept (struct rspamd_worker *worker)
{
- GList *cur;
- struct event *event;
+ GList *cur;
+ struct event *event;
/* Remove all events */
cur = worker->accept_events;
void
rspamd_controller_send_error (struct rspamd_http_connection_entry *entry,
- gint code,
- const gchar *error_msg)
+ gint code,
+ const gchar *error_msg)
{
struct rspamd_http_message *msg;
msg->status = g_string_new (error_msg);
rspamd_printf_gstring (msg->body, "{\"error\":\"%s\"}", error_msg);
rspamd_http_connection_reset (entry->conn);
- rspamd_http_connection_write_message (entry->conn, msg, NULL,
- "application/json", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
+ rspamd_http_connection_write_message (entry->conn,
+ msg,
+ NULL,
+ "application/json",
+ entry,
+ entry->conn->fd,
+ entry->rt->ptv,
+ entry->rt->ev_base);
entry->is_reply = TRUE;
}
void
rspamd_controller_send_string (struct rspamd_http_connection_entry *entry,
- const gchar *str)
+ const gchar *str)
{
struct rspamd_http_message *msg;
msg->code = 200;
msg->body = g_string_new (str);
rspamd_http_connection_reset (entry->conn);
- rspamd_http_connection_write_message (entry->conn, msg, NULL,
- "application/json", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
+ rspamd_http_connection_write_message (entry->conn,
+ msg,
+ NULL,
+ "application/json",
+ entry,
+ entry->conn->fd,
+ entry->rt->ptv,
+ entry->rt->ev_base);
entry->is_reply = TRUE;
}
void
rspamd_controller_send_ucl (struct rspamd_http_connection_entry *entry,
- ucl_object_t *obj)
+ ucl_object_t *obj)
{
struct rspamd_http_message *msg;
msg->body = g_string_sized_new (BUFSIZ);
rspamd_ucl_emit_gstring (obj, UCL_EMIT_JSON_COMPACT, msg->body);
rspamd_http_connection_reset (entry->conn);
- rspamd_http_connection_write_message (entry->conn, msg, NULL,
- "application/json", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
+ rspamd_http_connection_write_message (entry->conn,
+ msg,
+ NULL,
+ "application/json",
+ entry,
+ entry->conn->fd,
+ entry->rt->ptv,
+ entry->rt->ev_base);
entry->is_reply = TRUE;
}
#define WORKER_UTIL_H_
#include "config.h"
-#include "util.h"
#include "http.h"
+#include "util.h"
/**
* Return worker's control structure by its type
* @param type
* @return worker's control structure or NULL
*/
-worker_t* rspamd_get_worker_by_type (GQuark type);
+worker_t * rspamd_get_worker_by_type (GQuark type);
/**
* Set counter for a symbol
*/
struct event_base *
rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
- void (*accept_handler)(int, short, void *));
+ void (*accept_handler)(int, short, void *));
/**
* Stop accepting new connections for a worker
void rspamd_worker_stop_accept (struct rspamd_worker *worker);
typedef gint (*rspamd_controller_func_t) (
- struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg,
- struct module_ctx *ctx);
+ struct rspamd_http_connection_entry *conn_ent,
+ struct rspamd_http_message *msg,
+ struct module_ctx *ctx);
struct rspamd_custom_controller_command {
const gchar *command;
* @param error_msg error message
*/
void rspamd_controller_send_error (struct rspamd_http_connection_entry *entry,
- gint code,
- const gchar *error_msg);
+ gint code,
+ const gchar *error_msg);
/**
* Send a custom string using HTTP
* @param str string to send
*/
void rspamd_controller_send_string (struct rspamd_http_connection_entry *entry,
- const gchar *str);
+ const gchar *str);
/**
* Send UCL using HTTP and JSON serialization
* @param obj object to send
*/
void rspamd_controller_send_ucl (struct rspamd_http_connection_entry *entry,
- ucl_object_t *obj);
+ ucl_object_t *obj);
#endif /* WORKER_UTIL_H_ */
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
#include "aio_event.h"
+#include "config.h"
#include "main.h"
#ifdef HAVE_SYS_EVENTFD_H
# define SYS_io_submit 209
# define SYS_io_cancel 210
#else
-# warning "aio is not supported on this platform, please contact author for details"
+# warning \
+ "aio is not supported on this platform, please contact author for details"
# define SYS_io_setup 0
# define SYS_io_destroy 0
# define SYS_io_getevents 0
struct iocb {
/* these are internal to the kernel/libc. */
guint64 aio_data; /* data to be returned in event's data */
- guint32 PADDED(aio_key, aio_reserved1);
+ guint32 PADDED (aio_key, aio_reserved1);
/* the kernel sets aio_key to the req # */
/* common fields */
};
struct io_event {
- guint64 data; /* the data field from the iocb */
- guint64 obj; /* what iocb this event came from */
- gint64 res; /* result code for this event */
- gint64 res2; /* secondary result */
+ guint64 data; /* the data field from the iocb */
+ guint64 obj; /* what iocb this event came from */
+ gint64 res; /* result code for this event */
+ gint64 res2; /* secondary result */
};
/* Linux specific io calls */
static int
io_setup (guint nr_reqs, aio_context_t *ctx)
{
- return syscall (SYS_io_setup, nr_reqs, ctx);
+ return syscall (SYS_io_setup, nr_reqs, ctx);
}
static int
io_destroy (aio_context_t ctx)
{
- return syscall (SYS_io_destroy, ctx);
+ return syscall (SYS_io_destroy, ctx);
}
static int
-io_getevents (aio_context_t ctx, long min_nr, long nr, struct io_event *events, struct timespec *tmo)
+io_getevents (aio_context_t ctx,
+ long min_nr,
+ long nr,
+ struct io_event *events,
+ struct timespec *tmo)
{
return syscall (SYS_io_getevents, ctx, min_nr, nr, events, tmo);
}
static int
io_submit (aio_context_t ctx, long n, struct iocb **paiocb)
{
- return syscall (SYS_io_submit, ctx, n, paiocb);
+ return syscall (SYS_io_submit, ctx, n, paiocb);
}
static int
io_cancel (aio_context_t ctx, struct iocb *iocb, struct io_event *result)
{
- return syscall (SYS_io_cancel, ctx, iocb, result);
+ return syscall (SYS_io_cancel, ctx, iocb, result);
}
# ifndef HAVE_SYS_EVENTFD_H
*/
struct aio_context {
struct event_base *base;
- gboolean has_aio; /**< Whether we have aio support on a system */
+ gboolean has_aio; /**< Whether we have aio support on a system */
#ifdef LINUX
/* Eventfd variant */
gint event_fd;
static void
rspamd_eventfdcb (gint fd, gshort what, gpointer ud)
{
- struct aio_context *ctx = ud;
- guint64 ready;
- gint done, i;
- struct io_event event[32];
- struct timespec ts;
- struct io_cbdata *ev_data;
+ struct aio_context *ctx = ud;
+ guint64 ready;
+ gint done, i;
+ struct io_event event[32];
+ struct timespec ts;
+ struct io_cbdata *ev_data;
/* Eventfd returns number of events ready got from kernel */
if (read (fd, &ready, 8) != 8) {
if (done > 0) {
ready -= done;
- for (i = 0; i < done; i ++) {
+ for (i = 0; i < done; i++) {
ev_data = (struct io_cbdata *) (uintptr_t) event[i].data;
/* Call this callback */
- ev_data->cb (ev_data->fd, event[i].res, ev_data->len, ev_data->buf, ev_data->ud);
+ ev_data->cb (ev_data->fd,
+ event[i].res,
+ ev_data->len,
+ ev_data->buf,
+ ev_data->ud);
if (ev_data->io_buf) {
free (ev_data->io_buf);
}
/**
* Initialize aio with specified event base
*/
-struct aio_context*
+struct aio_context *
rspamd_aio_init (struct event_base *base)
{
- struct aio_context *new;
+ struct aio_context *new;
/* First of all we need to detect which type of aio we can try to use */
new = g_malloc0 (sizeof (struct aio_context));
close (new->event_fd);
}
else {
- event_set (&new->eventfd_ev, new->event_fd, EV_READ|EV_PERSIST, rspamd_eventfdcb, new);
+ event_set (&new->eventfd_ev,
+ new->event_fd,
+ EV_READ | EV_PERSIST,
+ rspamd_eventfdcb,
+ new);
event_base_set (new->base, &new->eventfd_ev);
event_add (&new->eventfd_ev, NULL);
if (io_setup (MAX_AIO_EV, &new->io_ctx) == -1) {
gint
rspamd_aio_open (struct aio_context *ctx, const gchar *path, int flags)
{
- gint fd = -1;
+ gint fd = -1;
/* Fallback */
if (!ctx->has_aio) {
return open (path, flags);
* Asynchronous read of file
*/
gint
-rspamd_aio_read (gint fd, gpointer buf, guint64 len, guint64 offset, struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud)
+rspamd_aio_read (gint fd,
+ gpointer buf,
+ guint64 len,
+ guint64 offset,
+ struct aio_context *ctx,
+ rspamd_aio_cb cb,
+ gpointer ud)
{
- struct io_cbdata *cbdata;
- gint r = -1;
+ struct io_cbdata *cbdata;
+ gint r = -1;
if (ctx->has_aio) {
#ifdef LINUX
- struct iocb *iocb[1];
+ struct iocb *iocb[1];
cbdata = g_slice_alloc (sizeof (struct io_cbdata));
cbdata->cb = cb;
* Asynchronous write of file
*/
gint
-rspamd_aio_write (gint fd, gpointer buf, guint64 len, guint64 offset, struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud)
+rspamd_aio_write (gint fd,
+ gpointer buf,
+ guint64 len,
+ guint64 offset,
+ struct aio_context *ctx,
+ rspamd_aio_cb cb,
+ gpointer ud)
{
- struct io_cbdata *cbdata;
- gint r = -1;
+ struct io_cbdata *cbdata;
+ gint r = -1;
if (ctx->has_aio) {
#ifdef LINUX
- struct iocb *iocb[1];
+ struct iocb *iocb[1];
cbdata = g_slice_alloc (sizeof (struct io_cbdata));
cbdata->cb = cb;
gint
rspamd_aio_close (gint fd, struct aio_context *ctx)
{
- gint r = -1;
+ gint r = -1;
if (ctx->has_aio) {
#ifdef LINUX
- struct iocb iocb;
- struct io_event ev;
+ struct iocb iocb;
+ struct io_event ev;
memset (&iocb, 0, sizeof (struct iocb));
iocb.aio_fildes = fd;
/**
* Callback for notifying
*/
-typedef void (*rspamd_aio_cb) (gint fd, gint res, guint64 len, gpointer data, gpointer ud);
+typedef void (*rspamd_aio_cb) (gint fd, gint res, guint64 len, gpointer data,
+ gpointer ud);
/**
* Initialize aio with specified event base
*/
-struct aio_context* rspamd_aio_init (struct event_base *base);
+struct aio_context * rspamd_aio_init (struct event_base *base);
/**
* Open file for aio
* Asynchronous read of file
*/
gint rspamd_aio_read (gint fd, gpointer buf, guint64 len, guint64 offset,
- struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
+ struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
/**
* Asynchronous write of file
*/
gint rspamd_aio_write (gint fd, gpointer buf, guint64 len, guint64 offset,
- struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
+ struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
/**
* Close of aio operations
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
#include "bloom.h"
+#include "config.h"
#include "xxhash.h"
/* 4 bits are used for counting (implementing delete operation) */
#define SIZE_BIT 4
/* These macroes are for 4 bits for counting element */
-#define INCBIT(a, n, acc) do { \
- acc = a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)); \
- acc ++; \
- acc &= 0xF; \
- \
- a[n * SIZE_BIT / CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT))); \
- a[n * SIZE_BIT / CHAR_BIT] |= (acc << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)); \
+#define INCBIT(a, n, acc) do { \
+ acc = \
+ a[n * SIZE_BIT / CHAR_BIT] & (0xF << \
+ (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)); \
+ acc ++; \
+ acc &= 0xF; \
+ \
+ a[n * SIZE_BIT / \
+ CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT))); \
+ a[n * SIZE_BIT / \
+ CHAR_BIT] |= (acc << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)); \
} while (0);
-#define DECBIT(a, n, acc) do { \
- acc = a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)); \
- acc --; \
- acc &= 0xF; \
- \
- a[n * SIZE_BIT / CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT))); \
- a[n * SIZE_BIT / CHAR_BIT] |= (acc << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)); \
+#define DECBIT(a, n, acc) do { \
+ acc = \
+ a[n * SIZE_BIT / CHAR_BIT] & (0xF << \
+ (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)); \
+ acc --; \
+ acc &= 0xF; \
+ \
+ a[n * SIZE_BIT / \
+ CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT))); \
+ a[n * SIZE_BIT / \
+ CHAR_BIT] |= (acc << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)); \
} while (0);
-#define GETBIT(a, n) (a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)))
+#define GETBIT(a, \
+ n) (a[n * SIZE_BIT / CHAR_BIT] & (0xF << \
+ (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)))
/* Common hash functions */
-rspamd_bloom_filter_t *
+rspamd_bloom_filter_t *
rspamd_bloom_create (size_t size, size_t nfuncs, ...)
{
- rspamd_bloom_filter_t *bloom;
- va_list l;
- gsize n;
+ rspamd_bloom_filter_t *bloom;
+ va_list l;
+ gsize n;
if (!(bloom = g_malloc (sizeof (rspamd_bloom_filter_t)))) {
return NULL;
}
- if (!(bloom->a = g_new0 (gchar, (size + CHAR_BIT - 1) / CHAR_BIT * SIZE_BIT))) {
+ if (!(bloom->a =
+ g_new0 (gchar, (size + CHAR_BIT - 1) / CHAR_BIT * SIZE_BIT))) {
g_free (bloom);
return NULL;
}
gboolean
rspamd_bloom_add (rspamd_bloom_filter_t * bloom, const gchar *s)
{
- size_t n, len;
- u_char t;
- guint v;
+ size_t n, len;
+ u_char t;
+ guint v;
if (s == NULL) {
return FALSE;
gboolean
rspamd_bloom_del (rspamd_bloom_filter_t * bloom, const gchar *s)
{
- size_t n, len;
- u_char t;
- guint v;
+ size_t n, len;
+ u_char t;
+ guint v;
if (s == NULL) {
return FALSE;
gboolean
rspamd_bloom_check (rspamd_bloom_filter_t * bloom, const gchar *s)
{
- size_t n, len;
- guint v;
+ size_t n, len;
+ guint v;
if (s == NULL) {
return FALSE;
#include "config.h"
typedef struct rspamd_bloom_filter_s {
- size_t asize;
- gchar *a;
- size_t nfuncs;
- guint32 *seeds;
+ size_t asize;
+ gchar *a;
+ size_t nfuncs;
+ guint32 *seeds;
} rspamd_bloom_filter_t;
* @param nfuncs number of hash functions
* @param ... hash functions list
*/
-rspamd_bloom_filter_t* rspamd_bloom_create (size_t size, size_t nfuncs, ...);
+rspamd_bloom_filter_t * rspamd_bloom_create (size_t size, size_t nfuncs, ...);
/*
* Destroy bloom filter
#include "diff.h"
-#define FV(k) _v(ctx, (k), 0)
-#define RV(k) _v(ctx, (k), 1)
+#define FV(k) _v (ctx, (k), 0)
+#define RV(k) _v (ctx, (k), 1)
#define MAX_DIFF 1024
};
static
-void maybe_resize_array(GArray *arr, guint k)
+void
+maybe_resize_array (GArray *arr, guint k)
{
if (k > arr->len) {
g_array_set_size (arr, k);
}
static void
-_setv(struct _ctx *ctx, gint k, gint r, gint val)
+_setv (struct _ctx *ctx, gint k, gint r, gint val)
{
gint j;
gint *i;
}
static gint
-_v(struct _ctx *ctx, gint k, gint r)
+_v (struct _ctx *ctx, gint k, gint r)
{
gint j;
}
static gint
-_find_middle_snake(const void *a, gint aoff, gint n, const void *b,
- gint boff, gint m, struct _ctx *ctx, struct middle_snake *ms)
+_find_middle_snake (const void *a, gint aoff, gint n, const void *b,
+ gint boff, gint m, struct _ctx *ctx, struct middle_snake *ms)
{
gint delta, odd, mid, d;
mid = (n + m) / 2;
mid += odd;
- _setv (ctx, 1, 0, 0);
+ _setv (ctx, 1, 0, 0);
_setv (ctx, delta - 1, 1, n);
for (d = 0; d <= mid; d++) {
}
for (k = d; k >= -d; k -= 2) {
- if (k == -d || (k != d && FV(k - 1) < FV(k + 1))) {
- x = FV(k + 1);
+ if (k == -d || (k != d && FV (k - 1) < FV (k + 1))) {
+ x = FV (k + 1);
}
else {
- x = FV(k - 1) + 1;
+ x = FV (k - 1) + 1;
}
y = x - k;
_setv (ctx, k, 0, x);
if (odd && k >= (delta - (d - 1)) && k <= (delta + (d - 1))) {
- if (x >= RV(k)) {
+ if (x >= RV (k)) {
ms->u = x;
ms->v = y;
return 2 * d - 1;
for (k = d; k >= -d; k -= 2) {
gint kr = (n - m) + k;
- if (k == d || (k != -d && RV(kr - 1) < RV(kr + 1))) {
- x = RV(kr - 1);
+ if (k == d || (k != -d && RV (kr - 1) < RV (kr + 1))) {
+ x = RV (kr - 1);
}
else {
- x = RV(kr + 1) - 1;
+ x = RV (kr + 1) - 1;
}
y = x - kr;
_setv (ctx, kr, 1, x);
if (!odd && kr >= -d && kr <= d) {
- if (x <= FV(kr)) {
+ if (x <= FV (kr)) {
ms->x = x;
ms->y = y;
return 2 * d;
}
static void
-_edit(struct _ctx *ctx, gint op, gint off, gint len)
+_edit (struct _ctx *ctx, gint op, gint off, gint len)
{
struct diff_edit *e = NULL, newe;
}
static gint
-_ses(const void *a, gint aoff, gint n, const void *b, gint boff,
- gint m, struct _ctx *ctx)
+_ses (const void *a, gint aoff, gint n, const void *b, gint boff,
+ gint m, struct _ctx *ctx)
{
struct middle_snake ms = {
.x = 0,
if (m > n) {
if (x == u) {
- _edit (ctx, DIFF_MATCH, aoff, n);
+ _edit (ctx, DIFF_MATCH, aoff, n);
_edit (ctx, DIFF_INSERT, boff + (m - 1), 1);
}
else {
_edit (ctx, DIFF_INSERT, boff, 1);
- _edit (ctx, DIFF_MATCH, aoff, n);
+ _edit (ctx, DIFF_MATCH, aoff, n);
}
}
else {
if (x == u) {
- _edit (ctx, DIFF_MATCH, aoff, m);
+ _edit (ctx, DIFF_MATCH, aoff, m);
_edit (ctx, DIFF_DELETE, aoff + (n - 1), 1);
}
else {
- _edit (ctx, DIFF_DELETE, aoff, 1);
- _edit (ctx, DIFF_MATCH, aoff + 1, m);
+ _edit (ctx, DIFF_DELETE, aoff, 1);
+ _edit (ctx, DIFF_MATCH, aoff + 1, m);
}
}
}
}
gint
-rspamd_diff(const void *a, gint aoff, gint n, const void *b, gint boff, gint m,
- gint dmax, GArray *ses, gint *sn)
+rspamd_diff (const void *a, gint aoff, gint n, const void *b, gint boff, gint m,
+ gint dmax, GArray *ses, gint *sn)
{
struct _ctx ctx;
gint d, x, y;
ses = g_array_sized_new (FALSE, TRUE, sizeof (struct diff_edit), MAX_DIFF);
if (rspamd_diff (s1->begin, 0, s1->len,
- s2->begin, 0, s2->len, MAX_DIFF, ses, NULL) == -1) {
+ s2->begin, 0, s2->len, MAX_DIFF, ses, NULL) == -1) {
/* Diff failed, strings are different */
g_array_free (ses, TRUE);
return 0;
}
- for (i = 0; i < ses->len; i ++) {
- e = &g_array_index(ses, struct diff_edit, i);
+ for (i = 0; i < ses->len; i++) {
+ e = &g_array_index (ses, struct diff_edit, i);
if (e->op != DIFF_MATCH) {
distance += e->len;
}
compare_diff_distance (f_str_t *s1, f_str_t *s2)
{
- return 100 - (2 * compare_diff_distance_unnormalized (s1, s2) * 100) / (s1->len + s2->len);
+ return 100 -
+ (2 *
+ compare_diff_distance_unnormalized (s1,
+ s2) * 100) / (s1->len + s2->len);
}
if (!g_ascii_isspace (*h)) {
*t++ = g_ascii_tolower (*h);
}
- h ++;
- p1 ++;
- r1 --;
+ h++;
+ p1++;
+ r1--;
}
t1.begin = b1;
if (!g_ascii_isspace (*h)) {
*t++ = g_ascii_tolower (*h);
}
- h ++;
- p2 ++;
- r2 --;
+ h++;
+ p2++;
+ r2--;
}
t2.begin = b2;
h = p1;
while (r1 > 0) {
if (!g_ascii_isspace (*h)) {
- cur_diff ++;
+ cur_diff++;
}
- r1 --;
- h ++;
+ r1--;
+ h++;
}
}
else if (r2 > 0) {
h = p2;
while (r2 > 0) {
if (!g_ascii_isspace (*h)) {
- cur_diff ++;
+ cur_diff++;
}
- r2 --;
- h ++;
+ r2--;
+ h++;
}
}
* @param sn here would be stored a number of differences between a and b
* @return distance between strings or -1 in case of error
*/
-gint rspamd_diff(const void *a, gint aoff, gint n, const void *b, gint boff, gint m,
- gint dmax, GArray *ses, gint *sn);
+gint rspamd_diff (const void *a,
+ gint aoff,
+ gint n,
+ const void *b,
+ gint boff,
+ gint m,
+ gint dmax,
+ GArray *ses,
+ gint *sn);
/*
* Calculate distance between two strings (in percentage) using diff algorithm.
* Calculate distance between two strings (in percentage) using diff algorithm. Strings are normalized before:
* all spaces are removed and all characters are lowercased.
* @return 100 in case of identical strings and 0 in case of totally different strings.
-*/
+ */
guint32 compare_diff_distance_normalized (f_str_t *s1, f_str_t *s2);
#endif /* DIFF_H_ */
ssize_t
fstrchr (f_str_t * src, gchar c)
{
- register size_t cur = 0;
+ register size_t cur = 0;
while (cur < src->len) {
if (*(src->begin + cur) == c) {
ssize_t
fstrrchr (f_str_t * src, gchar c)
{
- register ssize_t cur = src->len;
+ register ssize_t cur = src->len;
while (cur > 0) {
if (*(src->begin + cur) == c) {
ssize_t
fstrstr (f_str_t * orig, f_str_t * pattern)
{
- register size_t cur = 0, pcur = 0;
+ register size_t cur = 0, pcur = 0;
if (pattern->len > orig->len) {
return -1;
ssize_t
fstrstri (f_str_t * orig, f_str_t * pattern)
{
- register size_t cur = 0, pcur = 0;
+ register size_t cur = 0, pcur = 0;
if (pattern->len > orig->len) {
return -1;
}
while (cur < orig->len) {
- if (g_ascii_tolower (*(orig->begin + cur)) == g_ascii_tolower (*pattern->begin)) {
+ if (g_ascii_tolower (*(orig->begin + cur)) ==
+ g_ascii_tolower (*pattern->begin)) {
while (cur < orig->len && pcur < pattern->len) {
- if (g_ascii_tolower (*(orig->begin + cur)) != g_ascii_tolower (*(pattern->begin + pcur))) {
+ if (g_ascii_tolower (*(orig->begin + cur)) !=
+ g_ascii_tolower (*(pattern->begin + pcur))) {
pcur = 0;
break;
}
* word contains parsed word
*
* Return: -1 - no new words can be extracted
- * 1 - word was extracted and there are more words
- * 0 - last word extracted
+ * 1 - word was extracted and there are more words
+ * 0 - last word extracted
*/
gint
fstrtok (f_str_t * text, const gchar *sep, f_tok_t * state)
{
- register size_t cur;
- const gchar *csep = sep;
+ register size_t cur;
+ const gchar *csep = sep;
if (state->pos >= text->len) {
return -1;
size_t
fstrcpy (f_str_t * dest, f_str_t * src)
{
- register size_t cur = 0;
+ register size_t cur = 0;
if (dest->size < src->len) {
return 0;
size_t
fstrcat (f_str_t * dest, f_str_t * src)
{
- register size_t cur = 0;
- gchar *p = dest->begin + dest->len;
+ register size_t cur = 0;
+ gchar *p = dest->begin + dest->len;
if (dest->size < src->len + dest->len) {
return 0;
/*
* Make copy of string to 0-terminated string
*/
-gchar *
+gchar *
fstrcstr (f_str_t * str, rspamd_mempool_t * pool)
{
- gchar *res;
+ gchar *res;
res = rspamd_mempool_alloc (pool, str->len + 1);
/* Do not allow multiply \0 characters */
gint
fstrpush_unichar (f_str_t * dest, gunichar c)
{
- int l;
+ int l;
if (dest->size < dest->len) {
/* Need to reallocate string */
return 0;
/*
* Allocate memory for f_str_t
*/
-f_str_t *
+f_str_t *
fstralloc (rspamd_mempool_t * pool, size_t len)
{
- f_str_t *res = rspamd_mempool_alloc (pool, sizeof (f_str_t));
+ f_str_t *res = rspamd_mempool_alloc (pool, sizeof (f_str_t));
res->begin = rspamd_mempool_alloc (pool, len);
/*
* Allocate memory for f_str_t from temporary pool
*/
-f_str_t *
+f_str_t *
fstralloc_tmp (rspamd_mempool_t * pool, size_t len)
{
- f_str_t *res = rspamd_mempool_alloc_tmp (pool, sizeof (f_str_t));
+ f_str_t *res = rspamd_mempool_alloc_tmp (pool, sizeof (f_str_t));
res->begin = rspamd_mempool_alloc_tmp (pool, len);
/*
* Truncate string to its len
*/
-f_str_t *
+f_str_t *
fstrtruncate (rspamd_mempool_t * pool, f_str_t * orig)
{
- f_str_t *res;
+ f_str_t *res;
if (orig == NULL || orig->len == 0 || orig->size <= orig->len) {
return orig;
/*
* Enlarge string to new size
*/
-f_str_t *
+f_str_t *
fstrgrow (rspamd_mempool_t * pool, f_str_t * orig, size_t newlen)
{
- f_str_t *res;
+ f_str_t *res;
if (orig == NULL || orig->len == 0 || orig->size >= newlen) {
return orig;
static guint32
fstrhash_c (gchar c, guint32 hval)
{
- guint32 tmp;
+ guint32 tmp;
/*
* xor in the current byte against each byte of hval
* (which alone gaurantees that every bit of input will have
guint32
fstrhash (f_str_t * str)
{
- size_t i;
- guint32 hval;
- gchar *c = str->begin;
+ size_t i;
+ guint32 hval;
+ gchar *c = str->begin;
if (str == NULL) {
return 0;
guint32
fstrhash_lowercase (f_str_t * str, gboolean is_utf)
{
- gsize i;
- guint32 j, hval;
- const gchar *p = str->begin, *end = NULL;
- gchar t;
- gunichar uc;
+ gsize i;
+ guint32 j, hval;
+ const gchar *p = str->begin, *end = NULL;
+ gchar t;
+ gunichar uc;
if (str == NULL) {
return 0;
}
while (p < end) {
uc = g_unichar_tolower (g_utf8_get_char (p));
- for (j = 0; j < sizeof (gunichar); j ++) {
+ for (j = 0; j < sizeof (gunichar); j++) {
t = (uc >> (j * 8)) & 0xff;
if (t != 0) {
hval = fstrhash_c (t, hval);
void
fstrstrip (f_str_t * str)
{
- gchar *p = str->begin;
- guint r = 0;
+ gchar *p = str->begin;
+ guint r = 0;
while (r < str->len) {
if (g_ascii_isspace (*p)) {
#include "config.h"
#include "mem_pool.h"
-#define update_buf_size(x) (x)->free = (x)->buf->size - ((x)->pos - (x)->buf->begin); (x)->buf->len = (x)->pos - (x)->buf->begin
+#define update_buf_size(x) (x)->free = (x)->buf->size - \
+ ((x)->pos - (x)->buf->begin); (x)->buf->len = (x)->pos - (x)->buf->begin
typedef struct f_str_s {
gchar *begin;
/*
* Allocate memory for f_str_t
*/
-f_str_t* fstralloc (rspamd_mempool_t *pool, size_t len);
+f_str_t * fstralloc (rspamd_mempool_t *pool, size_t len);
/*
* Allocate memory for f_str_t from temporary pool
*/
-f_str_t* fstralloc_tmp (rspamd_mempool_t *pool, size_t len);
+f_str_t * fstralloc_tmp (rspamd_mempool_t *pool, size_t len);
/*
* Truncate string to its len
*/
-f_str_t* fstrtruncate (rspamd_mempool_t *pool, f_str_t *orig);
+f_str_t * fstrtruncate (rspamd_mempool_t *pool, f_str_t *orig);
/*
* Enlarge string to new size
*/
-f_str_t* fstrgrow (rspamd_mempool_t *pool, f_str_t *orig, size_t newlen);
+f_str_t * fstrgrow (rspamd_mempool_t *pool, f_str_t *orig, size_t newlen);
/*
* Return specified character
/*
* Make copy of string to 0-terminated string
*/
-gchar* fstrcstr (f_str_t *str, rspamd_mempool_t *pool);
+gchar * fstrcstr (f_str_t *str, rspamd_mempool_t *pool);
/*
* Strip fstr string from space symbols
#include "config.h"
-#include "mem_pool.h"
#include "fstring.h"
#include "fuzzy.h"
+#include "main.h"
+#include "mem_pool.h"
#include "message.h"
#include "url.h"
-#include "main.h"
#define ROLL_WINDOW_SIZE 9
#define MIN_FUZZY_BLOCK_SIZE 3
#define HASH_INIT 0x28021967
-static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char *b64 =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
struct roll_state {
- guint32 h[3];
- gchar window[ROLL_WINDOW_SIZE];
- gint n;
+ guint32 h[3];
+ gchar window[ROLL_WINDOW_SIZE];
+ gint n;
};
-static struct roll_state rs;
+static struct roll_state rs;
/* Rolling hash function based on Adler-32 checksum */
-static guint32
+static guint32
fuzzy_roll_hash (guint c)
{
/* Check window position */
}
/* A simple non-rolling hash, based on the FNV hash */
-static guint32
+static guint32
fuzzy_fnv_hash (guint c, guint32 hval)
{
hval ^= c;
- hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
+ hval +=
+ (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
return hval;
}
/* Calculate blocksize depending on length of input */
-static guint32
+static guint32
fuzzy_blocksize (guint32 len)
{
- guint32 nlen = MIN_FUZZY_BLOCK_SIZE;
+ guint32 nlen = MIN_FUZZY_BLOCK_SIZE;
while (nlen * (FUZZY_HASHLEN - 1) < len) {
nlen *= 2;
guint32
lev_distance (gchar *s1, gint len1, gchar *s2, gint len2)
{
- gint i;
- gint *row; /* we only need to keep one row of costs */
- gint *end;
- gint half, nx;
- gchar *sx, *char2p, char1;
- gint *p, D, x, offset, c3;
+ gint i;
+ gint *row; /* we only need to keep one row of costs */
+ gint *end;
+ gint half, nx;
+ gchar *sx, *char2p, char1;
+ gint *p, D, x, offset, c3;
/* strip common prefix */
while (len1 > 0 && len2 > 0 && *s1 == *s2) {
}
/* Calculate fuzzy hash for specified string */
-fuzzy_hash_t *
+fuzzy_hash_t *
fuzzy_init (f_str_t * in, rspamd_mempool_t * pool)
{
- fuzzy_hash_t *new;
- guint i, repeats = 0;
- gchar *c = in->begin, last = '\0';
- gsize real_len = 0;
+ fuzzy_hash_t *new;
+ guint i, repeats = 0;
+ gchar *c = in->begin, last = '\0';
+ gsize real_len = 0;
new = rspamd_mempool_alloc0 (pool, sizeof (fuzzy_hash_t));
bzero (&rs, sizeof (rs));
repeats = 0;
}
if (!g_ascii_isspace (*c) && !g_ascii_ispunct (*c) && repeats < 3) {
- real_len ++;
+ real_len++;
}
last = *c;
c++;
return new;
}
-fuzzy_hash_t *
+fuzzy_hash_t *
fuzzy_init_byte_array (GByteArray * in, rspamd_mempool_t * pool)
{
- f_str_t f;
+ f_str_t f;
f.begin = (gchar *)in->data;
f.len = in->len;
}
void
-fuzzy_init_part (struct mime_text_part *part, rspamd_mempool_t *pool, gsize max_diff)
+fuzzy_init_part (struct mime_text_part *part,
+ rspamd_mempool_t *pool,
+ gsize max_diff)
{
- fuzzy_hash_t *new, *new2;
- gchar *c, *end, *begin;
- gsize real_len = 0, len = part->content->len;
- GList *cur_offset;
- struct process_exception *cur_ex = NULL;
- gunichar uc;
- gboolean write_diff = FALSE;
+ fuzzy_hash_t *new, *new2;
+ gchar *c, *end, *begin;
+ gsize real_len = 0, len = part->content->len;
+ GList *cur_offset;
+ struct process_exception *cur_ex = NULL;
+ gunichar uc;
+ gboolean write_diff = FALSE;
cur_offset = part->urls_offset;
if (cur_offset != NULL) {
else {
uc = g_utf8_get_char (c);
if (g_unichar_isalnum (uc)) {
- real_len ++;
+ real_len++;
}
c = g_utf8_next_char (c);
}
}
else {
if (!g_ascii_isspace (*c) && !g_ascii_ispunct (*c)) {
- real_len ++;
+ real_len++;
}
c++;
}
gint
fuzzy_compare_hashes (fuzzy_hash_t * h1, fuzzy_hash_t * h2)
{
- gint res, l1, l2;
+ gint res, l1, l2;
/* If we have hashes of different size, input strings are too different */
if (h1->block_size != h2->block_size) {
return 0;
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
#define RSPAMD_FUZZY_H
#include "config.h"
-#include "mem_pool.h"
#include "fstring.h"
+#include "mem_pool.h"
#define FUZZY_HASHLEN 64
typedef struct fuzzy_hash_s {
- gchar hash_pipe[FUZZY_HASHLEN]; /**< result hash */
- guint32 block_size; /**< current blocksize */
- guint32 rh; /**< roll hash value */
- guint32 h; /**< hash of block */
- guint32 hi; /**< current index in hash pipe */
+ gchar hash_pipe[FUZZY_HASHLEN]; /**< result hash */
+ guint32 block_size; /**< current blocksize */
+ guint32 rh; /**< roll hash value */
+ guint32 h; /**< hash of block */
+ guint32 hi; /**< current index in hash pipe */
} fuzzy_hash_t;
struct mime_text_part;
* @param max_diff maximum text length to use diff algorithm in comparasions
* @return fuzzy_hash object allocated in pool
*/
-void fuzzy_init_part (struct mime_text_part *part, rspamd_mempool_t *pool, gsize max_diff);
+void fuzzy_init_part (struct mime_text_part *part,
+ rspamd_mempool_t *pool,
+ gsize max_diff);
/**
- * Compare score of difference between two hashes
+ * Compare score of difference between two hashes
* @param h1 first hash
* @param h2 second hash
- * @return result in percents 0 - different hashes, 100 - identical hashes
+ * @return result in percents 0 - different hashes, 100 - identical hashes
*/
gint fuzzy_compare_hashes (fuzzy_hash_t *h1, fuzzy_hash_t *h2);
* will use this function internally.
*/
static inline struct rspamd_hash_node **
-rspamd_hash_lookup_node (rspamd_hash_t * hash, gconstpointer key, guint * hash_return)
+rspamd_hash_lookup_node (rspamd_hash_t * hash,
+ gconstpointer key,
+ guint * hash_return)
{
- struct rspamd_hash_node **node_ptr, *node;
- guint hash_value;
- hash_value = (*hash->hash_func) (key);
+ struct rspamd_hash_node **node_ptr, *node;
+ guint hash_value;
+ hash_value = (*hash->hash_func)(key);
if (hash->shared) {
rspamd_mempool_rlock_rwlock (hash->lock);
*/
if (hash->key_equal_func) {
while ((node = *node_ptr)) {
- if (node->key_hash == hash_value && hash->key_equal_func (node->key, key)) {
+ if (node->key_hash == hash_value &&
+ hash->key_equal_func (node->key, key)) {
break;
}
node_ptr = &(*node_ptr)->next;
* No table resize is performed.
*/
static void
-rspamd_hash_remove_node (rspamd_hash_t * hash, struct rspamd_hash_node ***node_ptr_ptr)
+rspamd_hash_remove_node (rspamd_hash_t * hash,
+ struct rspamd_hash_node ***node_ptr_ptr)
{
- struct rspamd_hash_node **node_ptr, *node;
+ struct rspamd_hash_node **node_ptr, *node;
if (hash->shared) {
rspamd_mempool_wlock_rwlock (hash->lock);
static void
rspamd_hash_resize (rspamd_hash_t * hash)
{
- struct rspamd_hash_node **new_nodes;
- struct rspamd_hash_node *node, *next;
- guint hash_val;
- gint new_size, i;
+ struct rspamd_hash_node **new_nodes;
+ struct rspamd_hash_node *node, *next;
+ guint hash_val;
+ gint new_size, i;
new_size = g_spaced_primes_closest (hash->nnodes);
new_size = CLAMP (new_size, HASH_TABLE_MIN_SIZE, HASH_TABLE_MAX_SIZE);
if (hash->shared) {
- new_nodes = rspamd_mempool_alloc_shared (hash->pool, sizeof (struct rspamd_hash_node *) * new_size);
+ new_nodes =
+ rspamd_mempool_alloc_shared (hash->pool,
+ sizeof (struct rspamd_hash_node *) * new_size);
}
else {
- new_nodes = rspamd_mempool_alloc (hash->pool, sizeof (struct rspamd_hash_node *) * new_size);
+ new_nodes =
+ rspamd_mempool_alloc (hash->pool,
+ sizeof (struct rspamd_hash_node *) * new_size);
}
if (hash->shared) {
static inline void
rspamd_hash_maybe_resize (rspamd_hash_t * hash)
{
- gint nnodes = hash->nnodes;
- gint size = hash->size;
+ gint nnodes = hash->nnodes;
+ gint size = hash->size;
- if ((size >= 3 * nnodes && size > HASH_TABLE_MIN_SIZE) || (3 * size <= nnodes && size < HASH_TABLE_MAX_SIZE)) {
+ if ((size >= 3 * nnodes &&
+ size > HASH_TABLE_MIN_SIZE) ||
+ (3 * size <= nnodes && size < HASH_TABLE_MAX_SIZE)) {
rspamd_hash_resize (hash);
}
}
/* Create new hash in specified pool */
-rspamd_hash_t *
-rspamd_hash_new (rspamd_mempool_t * pool, GHashFunc hash_func, GEqualFunc key_equal_func)
+rspamd_hash_t *
+rspamd_hash_new (rspamd_mempool_t * pool,
+ GHashFunc hash_func,
+ GEqualFunc key_equal_func)
{
- rspamd_hash_t *hash;
+ rspamd_hash_t *hash;
hash = rspamd_mempool_alloc (pool, sizeof (rspamd_hash_t));
hash->size = HASH_TABLE_MIN_SIZE;
hash->nnodes = 0;
hash->hash_func = hash_func ? hash_func : g_direct_hash;
hash->key_equal_func = key_equal_func;
- hash->nodes = rspamd_mempool_alloc0 (pool, sizeof (struct rspamd_hash_node *) * hash->size);
+ hash->nodes = rspamd_mempool_alloc0 (pool,
+ sizeof (struct rspamd_hash_node *) * hash->size);
hash->shared = 0;
hash->pool = pool;
return hash;
}
-/*
- * Create new hash in specified pool using shared memory
+/*
+ * Create new hash in specified pool using shared memory
*/
-rspamd_hash_t *
-rspamd_hash_new_shared (rspamd_mempool_t * pool, GHashFunc hash_func, GEqualFunc key_equal_func, gint size)
+rspamd_hash_t *
+rspamd_hash_new_shared (rspamd_mempool_t * pool,
+ GHashFunc hash_func,
+ GEqualFunc key_equal_func,
+ gint size)
{
- rspamd_hash_t *hash;
+ rspamd_hash_t *hash;
hash = rspamd_mempool_alloc_shared (pool, sizeof (rspamd_hash_t));
hash->size = size;
hash->nnodes = 0;
hash->hash_func = hash_func ? hash_func : g_direct_hash;
hash->key_equal_func = key_equal_func;
- hash->nodes = rspamd_mempool_alloc0_shared (pool, sizeof (struct rspamd_hash_node *) * hash->size);
+ hash->nodes =
+ rspamd_mempool_alloc0_shared (pool,
+ sizeof (struct rspamd_hash_node *) * hash->size);
hash->shared = 1;
/* Get mutex from pool for locking on insert/remove operations */
hash->lock = rspamd_mempool_get_rwlock (pool);
return hash;
}
-/*
- * Insert item in hash
+/*
+ * Insert item in hash
*/
void
rspamd_hash_insert (rspamd_hash_t * hash, gpointer key, gpointer value)
{
- struct rspamd_hash_node **node_ptr, *node;
- guint key_hash;
+ struct rspamd_hash_node **node_ptr, *node;
+ guint key_hash;
g_return_if_fail (hash != NULL);
node_ptr = rspamd_hash_lookup_node (hash, key, &key_hash);
}
else {
if (hash->shared) {
- node = rspamd_mempool_alloc_shared (hash->pool, sizeof (struct rspamd_hash_node));
+ node =
+ rspamd_mempool_alloc_shared (hash->pool,
+ sizeof (struct rspamd_hash_node));
}
else {
- node = rspamd_mempool_alloc (hash->pool, sizeof (struct rspamd_hash_node));
+ node =
+ rspamd_mempool_alloc (hash->pool,
+ sizeof (struct rspamd_hash_node));
}
node->key = key;
}
}
-/*
- * Remove item from hash
+/*
+ * Remove item from hash
*/
gboolean
rspamd_hash_remove (rspamd_hash_t * hash, gpointer key)
{
- struct rspamd_hash_node **node_ptr;
+ struct rspamd_hash_node **node_ptr;
g_return_val_if_fail (hash != NULL, FALSE);
return TRUE;
}
-/*
- * Lookup item from hash
+/*
+ * Lookup item from hash
*/
gpointer
rspamd_hash_lookup (rspamd_hash_t * hash, gpointer key)
{
- struct rspamd_hash_node *node;
+ struct rspamd_hash_node *node;
g_return_val_if_fail (hash != NULL, NULL);
node = *rspamd_hash_lookup_node (hash, key, NULL);
return node ? node->value : NULL;
}
-/*
- * Iterate throught hash
+/*
+ * Iterate throught hash
*/
void
rspamd_hash_foreach (rspamd_hash_t * hash, GHFunc func, gpointer user_data)
{
- struct rspamd_hash_node *node;
- gint i;
+ struct rspamd_hash_node *node;
+ gint i;
g_return_if_fail (hash != NULL);
g_return_if_fail (func != NULL);
}
for (i = 0; i < hash->size; i++) {
for (node = hash->nodes[i]; node; node = node->next) {
- (*func) (node->key, node->value, user_data);
+ (*func)(node->key, node->value, user_data);
}
}
if (hash->shared) {
static void
rspamd_lru_hash_destroy_node (gpointer v)
{
- rspamd_lru_element_t *node = v;
+ rspamd_lru_element_t *node = v;
if (node->hash->value_destroy) {
node->hash->value_destroy (node->data);
g_slice_free1 (sizeof (rspamd_lru_element_t), node);
}
-static rspamd_lru_element_t*
-rspamd_lru_create_node (rspamd_lru_hash_t *hash, gpointer key, gpointer value, time_t now, guint ttl)
+static rspamd_lru_element_t *
+rspamd_lru_create_node (rspamd_lru_hash_t *hash,
+ gpointer key,
+ gpointer value,
+ time_t now,
+ guint ttl)
{
- rspamd_lru_element_t *node;
+ rspamd_lru_element_t *node;
node = g_slice_alloc (sizeof (rspamd_lru_element_t));
node->data = value;
* @param key_equal_func pointer to function for comparing keys
* @return new rspamd_hash object
*/
-rspamd_lru_hash_t*
-rspamd_lru_hash_new (GHashFunc hash_func, GEqualFunc key_equal_func, gint maxsize, gint maxage,
- GDestroyNotify key_destroy, GDestroyNotify value_destroy)
+rspamd_lru_hash_t *
+rspamd_lru_hash_new (GHashFunc hash_func,
+ GEqualFunc key_equal_func,
+ gint maxsize,
+ gint maxage,
+ GDestroyNotify key_destroy,
+ GDestroyNotify value_destroy)
{
- rspamd_lru_hash_t *new;
+ rspamd_lru_hash_t *new;
new = g_malloc (sizeof (rspamd_lru_hash_t));
- new->storage = g_hash_table_new_full (hash_func, key_equal_func, key_destroy, rspamd_lru_hash_destroy_node);
+ new->storage = g_hash_table_new_full (hash_func,
+ key_equal_func,
+ key_destroy,
+ rspamd_lru_hash_destroy_node);
new->maxage = maxage;
new->maxsize = maxsize;
new->value_destroy = value_destroy;
* @param key_equal_func pointer to function for comparing keys
* @return new rspamd_hash object
*/
-rspamd_lru_hash_t*
-rspamd_lru_hash_new_full (GHashFunc hash_func, GEqualFunc key_equal_func,
- gint maxsize, gint maxage, GDestroyNotify key_destroy, GDestroyNotify value_destroy,
- gpointer storage, lru_cache_insert_func insert_func, lru_cache_lookup_func lookup_func,
- lru_cache_delete_func delete_func)
+rspamd_lru_hash_t *
+rspamd_lru_hash_new_full (GHashFunc hash_func,
+ GEqualFunc key_equal_func,
+ gint maxsize,
+ gint maxage,
+ GDestroyNotify key_destroy,
+ GDestroyNotify value_destroy,
+ gpointer storage,
+ lru_cache_insert_func insert_func,
+ lru_cache_lookup_func lookup_func,
+ lru_cache_delete_func delete_func)
{
- rspamd_lru_hash_t *new;
+ rspamd_lru_hash_t *new;
new = g_malloc (sizeof (rspamd_lru_hash_t));
new->storage = storage;
gpointer
rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash, gpointer key, time_t now)
{
- rspamd_lru_element_t *res;
+ rspamd_lru_element_t *res;
if ((res = hash->lookup_func (hash->storage, key)) != NULL) {
if (res->ttl != 0) {
*/
void
rspamd_lru_hash_insert (rspamd_lru_hash_t *hash, gpointer key, gpointer value,
- time_t now, guint ttl)
+ time_t now, guint ttl)
{
- rspamd_lru_element_t *res;
- gint removed = 0;
+ rspamd_lru_element_t *res;
+ gint removed = 0;
if ((res = hash->lookup_func (hash->storage, key)) != NULL) {
hash->delete_func (hash->storage, res->key);
}
else {
if (hash->maxsize > 0 &&
- (gint)g_queue_get_length (hash->q) >= hash->maxsize) {
+ (gint)g_queue_get_length (hash->q) >= hash->maxsize) {
/* Expire some elements */
res = g_queue_peek_tail (hash->q);
if (hash->maxage > 0) {
break;
}
res = g_queue_peek_tail (hash->q);
- removed ++;
+ removed++;
}
}
if (removed == 0) {
#include "mem_pool.h"
struct rspamd_hash_node {
- gpointer key;
- gpointer value;
- guint key_hash;
+ gpointer key;
+ gpointer value;
+ guint key_hash;
struct rspamd_hash_node *next;
};
typedef struct rspamd_hash_s {
- gint size;
- gint nnodes;
+ gint size;
+ gint nnodes;
struct rspamd_hash_node **nodes;
- GHashFunc hash_func;
- GEqualFunc key_equal_func;
- gint shared;
- rspamd_mempool_rwlock_t *lock;
- rspamd_mempool_t *pool;
+ GHashFunc hash_func;
+ GEqualFunc key_equal_func;
+ gint shared;
+ rspamd_mempool_rwlock_t *lock;
+ rspamd_mempool_t *pool;
} rspamd_hash_t;
-typedef void (*lru_cache_insert_func)(gpointer storage, gpointer key, gpointer value);
+typedef void (*lru_cache_insert_func)(gpointer storage, gpointer key,
+ gpointer value);
typedef gpointer (*lru_cache_lookup_func)(gpointer storage, gpointer key);
typedef gboolean (*lru_cache_delete_func)(gpointer storage, gpointer key);
typedef void (*lru_cache_destroy_func)(gpointer storage);
typedef struct rspamd_lru_hash_s {
- gint maxsize;
- gint maxage;
- GDestroyNotify value_destroy;
- GDestroyNotify key_destroy;
- GQueue *q;
- gpointer storage;
- lru_cache_insert_func insert_func;
- lru_cache_lookup_func lookup_func;
- lru_cache_delete_func delete_func;
- lru_cache_destroy_func destroy_func;
+ gint maxsize;
+ gint maxage;
+ GDestroyNotify value_destroy;
+ GDestroyNotify key_destroy;
+ GQueue *q;
+ gpointer storage;
+ lru_cache_insert_func insert_func;
+ lru_cache_lookup_func lookup_func;
+ lru_cache_delete_func delete_func;
+ lru_cache_destroy_func destroy_func;
} rspamd_lru_hash_t;
typedef struct rspamd_lru_element_s {
- gpointer data;
- gpointer key;
- time_t store_time;
- guint ttl;
- rspamd_lru_hash_t *hash;
- GList *link;
+ gpointer data;
+ gpointer key;
+ time_t store_time;
+ guint ttl;
+ rspamd_lru_hash_t *hash;
+ GList *link;
} rspamd_lru_element_t;
* @param key_equal_func pointer to function for comparing keys
* @return new rspamd_hash object
*/
-rspamd_hash_t* rspamd_hash_new (rspamd_mempool_t *pool, GHashFunc hash_func, GEqualFunc key_equal_func);
+rspamd_hash_t * rspamd_hash_new (rspamd_mempool_t *pool,
+ GHashFunc hash_func,
+ GEqualFunc key_equal_func);
/**
* Create new hash in specified pool using shared memory
* @param key_equal_func pointer to function for comparing keys
* @return new rspamd_hash object
*/
-rspamd_hash_t* rspamd_hash_new_shared (rspamd_mempool_t *pool, GHashFunc hash_func, GEqualFunc key_equal_func, gint size);
+rspamd_hash_t * rspamd_hash_new_shared (rspamd_mempool_t *pool,
+ GHashFunc hash_func,
+ GEqualFunc key_equal_func,
+ gint size);
/**
* Insert item in hash
*/
gpointer rspamd_hash_lookup (rspamd_hash_t *hash, gpointer key);
-/**
+/**
* Iterate throught hash
* @param hash hash object
* @param func user's function that would be called for each key/value pair
* @param key_equal_func pointer to function for comparing keys
* @return new rspamd_hash object
*/
-rspamd_lru_hash_t* rspamd_lru_hash_new (GHashFunc hash_func, GEqualFunc key_equal_func,
- gint maxsize, gint maxage, GDestroyNotify key_destroy, GDestroyNotify value_destroy);
+rspamd_lru_hash_t * rspamd_lru_hash_new (GHashFunc hash_func,
+ GEqualFunc key_equal_func,
+ gint maxsize,
+ gint maxage,
+ GDestroyNotify key_destroy,
+ GDestroyNotify value_destroy);
/**
* Create new lru hash with custom storage
* @param key_equal_func pointer to function for comparing keys
* @return new rspamd_hash object
*/
-rspamd_lru_hash_t* rspamd_lru_hash_new_full (GHashFunc hash_func, GEqualFunc key_equal_func,
- gint maxsize, gint maxage, GDestroyNotify key_destroy, GDestroyNotify value_destroy,
- gpointer storage, lru_cache_insert_func insert_func, lru_cache_lookup_func lookup_func,
- lru_cache_delete_func delete_func);
+rspamd_lru_hash_t * rspamd_lru_hash_new_full (GHashFunc hash_func,
+ GEqualFunc key_equal_func,
+ gint maxsize,
+ gint maxage,
+ GDestroyNotify key_destroy,
+ GDestroyNotify value_destroy,
+ gpointer storage,
+ lru_cache_insert_func insert_func,
+ lru_cache_lookup_func lookup_func,
+ lru_cache_delete_func delete_func);
/**
* Lookup item from hash
* @param hash hash object
* @param key key to find
* @return value of key or NULL if key is not found
*/
-gpointer rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash, gpointer key, time_t now);
+gpointer rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash,
+ gpointer key,
+ time_t now);
/**
* Insert item in hash
* @param hash hash object
* @param key key to insert
* @param value value of key
*/
-void rspamd_lru_hash_insert (rspamd_lru_hash_t *hash, gpointer key, gpointer value,
- time_t now, guint ttl);
+void rspamd_lru_hash_insert (rspamd_lru_hash_t *hash,
+ gpointer key,
+ gpointer value,
+ time_t now,
+ guint ttl);
/**
* Remove lru hash
#include "config.h"
#include "http.h"
-#include "utlist.h"
-#include "util.h"
-#include "printf.h"
#include "logger.h"
+#include "printf.h"
+#include "util.h"
+#include "utlist.h"
struct rspamd_http_connection_private {
GString *buf;
[HTTP_MAGIC_JPG] = { "jpg", "image/jpeg" },
};
-static gchar *http_week[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-static gchar *http_month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+static gchar *http_week[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+static gchar *http_month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
#define HTTP_ERROR http_error_quark ()
if (fmt == rfc822) {
if (*p < '0' || *p > '9' || *(p + 1) < '0' || *(p + 1) > '9'
- || *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
- || *(p + 3) > '9') {
+ || *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
+ || *(p + 3) > '9') {
return (time_t)-1;
}
year = (*p - '0') * 1000 + (*(p + 1) - '0') * 100
- + (*(p + 2) - '0') * 10 + *(p + 3) - '0';
+ + (*(p + 2) - '0') * 10 + *(p + 3) - '0';
p += 4;
}
}
if (*p < '0' || *p > '9' || *(p + 1) < '0' || *(p + 1) > '9'
- || *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
- || *(p + 3) > '9') {
+ || *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
+ || *(p + 3) > '9') {
return (time_t)-1;
}
year = (*p - '0') * 1000 + (*(p + 1) - '0') * 100
- + (*(p + 2) - '0') * 10 + *(p + 3) - '0';
+ + (*(p + 2) - '0') * 10 + *(p + 3) - '0';
}
if (hour > 23 || min > 59 || sec > 59) {
/* Gauss' formula for Gregorian days since March 1, 1 BC */
time = (guint64) (
- /* days in years including leap years since March 1, 1 BC */
+ /* days in years including leap years since March 1, 1 BC */
- 365 * year + year / 4 - year / 100 + year / 400
+ 365 * year + year / 4 - year / 100 + year / 400
- /* days before the month */
+ /* days before the month */
- + 367 * month / 12 - 30
+ + 367 * month / 12 - 30
- /* days before the day */
+ /* days before the day */
- + day - 1
+ + day - 1
- /*
- * 719527 days were between March 1, 1 BC and March 1, 1970,
- * 31 and 28 days were in January and February 1970
- */
+ /*
+ * 719527 days were between March 1, 1 BC and March 1, 1970,
+ * 31 and 28 days were in January and February 1970
+ */
- - 719527 + 31 + 28) * 86400 + hour * 3600 + min * 60 + sec;
+ - 719527 + 31 + 28) * 86400 + hour * 3600 + min * 60 + sec;
return (time_t) time;
}
}
static gint
-rspamd_http_on_url (http_parser* parser, const gchar *at, size_t length)
+rspamd_http_on_url (http_parser * parser, const gchar *at, size_t length)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
priv = conn->priv;
}
static gint
-rspamd_http_on_status (http_parser* parser, const gchar *at, size_t length)
+rspamd_http_on_status (http_parser * parser, const gchar *at, size_t length)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
priv = conn->priv;
}
static gint
-rspamd_http_on_header_field (http_parser* parser, const gchar *at, size_t length)
+rspamd_http_on_header_field (http_parser * parser,
+ const gchar *at,
+ size_t length)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
priv = conn->priv;
}
static gint
-rspamd_http_on_header_value (http_parser* parser, const gchar *at, size_t length)
+rspamd_http_on_header_value (http_parser * parser,
+ const gchar *at,
+ size_t length)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
priv = conn->priv;
}
static int
-rspamd_http_on_headers_complete (http_parser* parser)
+rspamd_http_on_headers_complete (http_parser * parser)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
priv = conn->priv;
}
static int
-rspamd_http_on_body (http_parser* parser, const gchar *at, size_t length)
+rspamd_http_on_body (http_parser * parser, const gchar *at, size_t length)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
priv = conn->priv;
}
static int
-rspamd_http_on_message_complete (http_parser* parser)
+rspamd_http_on_message_complete (http_parser * parser)
{
- struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
+ struct rspamd_http_connection *conn =
+ (struct rspamd_http_connection *)parser->data;
struct rspamd_http_connection_private *priv;
int ret = 0;
ret = conn->body_handler (conn, priv->msg, NULL, 0);
}
else {
- ret = conn->body_handler (conn, priv->msg, priv->msg->body->str, priv->msg->body->len);
+ ret = conn->body_handler (conn,
+ priv->msg,
+ priv->msg->body->str,
+ priv->msg->body->len);
}
rspamd_http_connection_unref (conn);
}
start = &priv->out[0];
niov = priv->outlen;
remain = priv->wr_pos;
- for (i = 0; i < priv->outlen && remain > 0; i ++) {
+ for (i = 0; i < priv->outlen && remain > 0; i++) {
/* Find out the first iov required */
start = &priv->out[i];
if (start->iov_len <= remain) {
remain -= start->iov_len;
start = &priv->out[i + 1];
- niov --;
+ niov--;
}
else {
start->iov_base = (void *)((char *)start->iov_base + remain);
r = writev (conn->fd, start, MIN (IOV_MAX, niov));
if (r == -1) {
- err = g_error_new (HTTP_ERROR, errno, "IO write error: %s", strerror (errno));
+ err =
+ g_error_new (HTTP_ERROR, errno, "IO write error: %s", strerror (
+ errno));
rspamd_http_connection_ref (conn);
conn->error_handler (conn, err);
rspamd_http_connection_unref (conn);
if (what == EV_READ) {
r = read (fd, buf->str, buf->allocated_len);
if (r == -1) {
- err = g_error_new (HTTP_ERROR, errno, "IO read error: %s", strerror (errno));
+ err = g_error_new (HTTP_ERROR,
+ errno,
+ "IO read error: %s",
+ strerror (errno));
conn->error_handler (conn, err);
g_error_free (err);
return;
return;
}
else {
- err = g_error_new (HTTP_ERROR, errno, "IO read error: unexpected EOF");
+ err = g_error_new (HTTP_ERROR,
+ errno,
+ "IO read error: unexpected EOF");
conn->error_handler (conn, err);
g_error_free (err);
return;
else {
buf->len = r;
rspamd_http_connection_ref (conn);
- if (http_parser_execute (&priv->parser, &priv->parser_cb, buf->str, r) != (size_t)r) {
+ if (http_parser_execute (&priv->parser, &priv->parser_cb, buf->str,
+ r) != (size_t)r) {
err = g_error_new (HTTP_ERROR, priv->parser.http_errno,
- "HTTP parser error: %s", http_errno_description (priv->parser.http_errno));
+ "HTTP parser error: %s",
+ http_errno_description (priv->parser.http_errno));
conn->error_handler (conn, err);
g_error_free (err);
rspamd_http_connection_unref (conn);
}
}
-struct rspamd_http_connection*
+struct rspamd_http_connection *
rspamd_http_connection_new (rspamd_http_body_handler_t body_handler,
- rspamd_http_error_handler_t error_handler,
- rspamd_http_finish_handler_t finish_handler,
- enum rspamd_http_options opts,
- enum rspamd_http_connection_type type)
+ rspamd_http_error_handler_t error_handler,
+ rspamd_http_finish_handler_t finish_handler,
+ enum rspamd_http_options opts,
+ enum rspamd_http_connection_type type)
{
struct rspamd_http_connection *new;
struct rspamd_http_connection_private *priv;
/* Init priv */
priv = g_slice_alloc0 (sizeof (struct rspamd_http_connection_private));
- http_parser_init (&priv->parser, type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
+ http_parser_init (&priv->parser,
+ type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
priv->parser.data = new;
priv->parser_cb.on_url = rspamd_http_on_url;
priv->parser_cb.on_status = rspamd_http_on_status;
priv = conn->priv;
rspamd_http_connection_reset (conn);
g_slice_free1 (sizeof (struct rspamd_http_connection_private), priv);
- g_slice_free1 (sizeof (struct rspamd_http_connection), conn);
+ g_slice_free1 (sizeof (struct rspamd_http_connection), conn);
}
void
rspamd_http_connection_read_message (struct rspamd_http_connection *conn,
- gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
+ gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
{
struct rspamd_http_connection_private *priv = conn->priv;
struct rspamd_http_message *req;
conn->fd = fd;
conn->ud = ud;
- req = rspamd_http_new_message (conn->type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
+ req = rspamd_http_new_message (
+ conn->type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
priv->msg = req;
if (timeout == NULL) {
priv->buf = g_string_sized_new (BUFSIZ);
priv->new_header = TRUE;
- event_set (&priv->ev, fd, EV_READ | EV_PERSIST, rspamd_http_event_handler, conn);
+ event_set (&priv->ev,
+ fd,
+ EV_READ | EV_PERSIST,
+ rspamd_http_event_handler,
+ conn);
event_base_set (base, &priv->ev);
event_add (&priv->ev, priv->ptv);
}
void
rspamd_http_connection_write_message (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg, const gchar *host, const gchar *mime_type,
- gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
+ struct rspamd_http_message *msg, const gchar *host, const gchar *mime_type,
+ gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
{
struct rspamd_http_connection_private *priv = conn->priv;
struct rspamd_http_header *hdr;
if (msg->method < HTTP_SYMBOLS) {
ptm = gmtime (&msg->date);
t = *ptm;
- rspamd_snprintf (datebuf, sizeof (datebuf), "%s, %02d %s %4d %02d:%02d:%02d GMT",
- http_week[t.tm_wday],
- t.tm_mday,
- http_month[t.tm_mon],
- t.tm_year + 1900,
- t.tm_hour,
- t.tm_min,
- t.tm_sec);
+ rspamd_snprintf (datebuf,
+ sizeof (datebuf),
+ "%s, %02d %s %4d %02d:%02d:%02d GMT",
+ http_week[t.tm_wday],
+ t.tm_mday,
+ http_month[t.tm_mon],
+ t.tm_year + 1900,
+ t.tm_hour,
+ t.tm_min,
+ t.tm_sec);
if (mime_type == NULL) {
mime_type = "text/plain";
}
rspamd_printf_gstring (priv->buf, "HTTP/1.1 %d %s\r\n"
- "Connection: close\r\n"
- "Server: %s\r\n"
- "Date: %s\r\n"
- "Content-Length: %z\r\n"
- "Content-Type: %s\r\n",
- msg->code,
- msg->status ? msg->status->str : rspamd_http_code_to_str (msg->code),
- "rspamd/" RVERSION,
- datebuf,
- bodylen,
- mime_type);
+ "Connection: close\r\n"
+ "Server: %s\r\n"
+ "Date: %s\r\n"
+ "Content-Length: %z\r\n"
+ "Content-Type: %s\r\n",
+ msg->code,
+ msg->status ? msg->status->str : rspamd_http_code_to_str (msg->
+ code),
+ "rspamd/" RVERSION,
+ datebuf,
+ bodylen,
+ mime_type);
}
else {
/* Legacy spamd reply */
/* Format request */
if (host != NULL) {
rspamd_printf_gstring (priv->buf, "%s %v HTTP/1.1\r\n"
- "Connection: close\r\n"
- "Host: %s\r\n"
- "Content-Length: %z\r\n",
+ "Connection: close\r\n"
+ "Host: %s\r\n"
+ "Content-Length: %z\r\n",
http_method_str (msg->method), msg->url, host, bodylen);
}
else {
/* Fallback to HTTP/1.0 */
rspamd_printf_gstring (priv->buf, "%s %v HTTP/1.0\r\n"
- "Content-Length: %z\r\n",
+ "Content-Length: %z\r\n",
http_method_str (msg->method), msg->url, bodylen);
}
}
/* Allocate iov */
priv->wr_total = bodylen + priv->buf->len + 2;
- DL_FOREACH (msg->headers, hdr) {
+ DL_FOREACH (msg->headers, hdr)
+ {
/* <name><: ><value><\r\n> */
priv->wr_total += hdr->name->len + hdr->value->len + 4;
priv->outlen += 4;
priv->out[0].iov_base = priv->buf->str;
priv->out[0].iov_len = priv->buf->len;
i = 1;
- LL_FOREACH (msg->headers, hdr) {
+ LL_FOREACH (msg->headers, hdr)
+ {
priv->out[i].iov_base = hdr->name->str;
priv->out[i++].iov_len = hdr->name->len;
priv->out[i].iov_base = ": ";
event_add (&priv->ev, priv->ptv);
}
-struct rspamd_http_message*
+struct rspamd_http_message *
rspamd_http_new_message (enum http_parser_type type)
{
struct rspamd_http_message *new;
{
struct rspamd_http_header *hdr, *tmp_hdr;
- LL_FOREACH_SAFE (msg->headers, hdr, tmp_hdr) {
- g_string_free (hdr->name, TRUE);
+ LL_FOREACH_SAFE (msg->headers, hdr, tmp_hdr)
+ {
+ g_string_free (hdr->name, TRUE);
g_string_free (hdr->value, TRUE);
g_slice_free1 (sizeof (struct rspamd_http_header), hdr);
}
g_slice_free1 (sizeof (struct rspamd_http_message), msg);
}
-void rspamd_http_message_add_header (struct rspamd_http_message *msg,
- const gchar *name,
- const gchar *value)
+void
+rspamd_http_message_add_header (struct rspamd_http_message *msg,
+ const gchar *name,
+ const gchar *value)
{
struct rspamd_http_header *hdr;
}
}
-const gchar*
-rspamd_http_message_find_header (struct rspamd_http_message *msg, const gchar *name)
+const gchar *
+rspamd_http_message_find_header (struct rspamd_http_message *msg,
+ const gchar *name)
{
struct rspamd_http_header *hdr;
const gchar *res = NULL;
guint slen = strlen (name);
if (msg != NULL) {
- LL_FOREACH (msg->headers, hdr) {
+ LL_FOREACH (msg->headers, hdr)
+ {
if (hdr->name->len == slen) {
if (memcmp (hdr->name->str, name, slen) == 0) {
res = hdr->value->str;
}
static void
-rspamd_http_router_error_handler (struct rspamd_http_connection *conn, GError *err)
+rspamd_http_router_error_handler (struct rspamd_http_connection *conn,
+ GError *err)
{
struct rspamd_http_connection_entry *entry = conn->ud;
struct rspamd_http_message *msg;
msg->code = err->code;
msg->body = g_string_new (err->message);
rspamd_http_connection_reset (entry->conn);
- rspamd_http_connection_write_message (entry->conn, msg, NULL,
- "text/plain", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
+ rspamd_http_connection_write_message (entry->conn,
+ msg,
+ NULL,
+ "text/plain",
+ entry,
+ entry->conn->fd,
+ entry->rt->ptv,
+ entry->rt->ev_base);
entry->is_reply = TRUE;
}
}
if (dot == NULL) {
return http_file_types[HTTP_MAGIC_PLAIN].ct;
}
- dot ++;
+ dot++;
- for (i = 0; i < G_N_ELEMENTS (http_file_types); i ++) {
+ for (i = 0; i < G_N_ELEMENTS (http_file_types); i++) {
if (strcmp (http_file_types[i].ext, dot) == 0) {
return http_file_types[i].ct;
}
if (*sub != *parent) {
return FALSE;
}
- parent ++;
- sub ++;
+ parent++;
+ sub++;
}
- parent --;
+ parent--;
if (*parent == G_DIR_SEPARATOR) {
return TRUE;
}
static gboolean
rspamd_http_router_try_file (struct rspamd_http_connection_entry *entry,
- struct rspamd_http_message *msg, gboolean expand_path)
+ struct rspamd_http_message *msg, gboolean expand_path)
{
struct stat st;
gint fd;
struct rspamd_http_message *reply_msg;
rspamd_snprintf (filebuf, sizeof (filebuf), "%s%c%v",
- entry->rt->default_fs_path, G_DIR_SEPARATOR, msg->url);
+ entry->rt->default_fs_path, G_DIR_SEPARATOR, msg->url);
if (realpath (filebuf, realbuf) == NULL ||
- lstat (realbuf, &st) == -1) {
+ lstat (realbuf, &st) == -1) {
return FALSE;
}
if (S_ISDIR (st.st_mode) && expand_path) {
/* Try to append 'index.html' to the url */
g_string_append_printf (msg->url, "%c%s", G_DIR_SEPARATOR,
- "index.html");
+ "index.html");
return rspamd_http_router_try_file (entry, msg, FALSE);
}
else if (!S_ISREG (st.st_mode)) {
/* We also need to ensure that file is inside the defined dir */
rspamd_strlcpy (filebuf, realbuf, sizeof (filebuf));
dir = dirname (filebuf);
- if (dir == NULL || !rspamd_http_router_is_subdir (entry->rt->default_fs_path,
- dir)) {
+ if (dir == NULL ||
+ !rspamd_http_router_is_subdir (entry->rt->default_fs_path,
+ dir)) {
return FALSE;
}
/* XXX: detect content type */
rspamd_http_connection_write_message (entry->conn, reply_msg, NULL,
- rspamd_http_router_detect_ct (realbuf), entry, entry->conn->fd,
- entry->rt->ptv, entry->rt->ev_base);
+ rspamd_http_router_detect_ct (realbuf), entry, entry->conn->fd,
+ entry->rt->ptv, entry->rt->ev_base);
return TRUE;
}
static int
rspamd_http_router_finish_handler (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
struct rspamd_http_connection_entry *entry = conn->ud;
rspamd_http_router_handler_t handler = NULL;
struct rspamd_http_message *err_msg;
GError *err;
- G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) == sizeof (gpointer));
+ G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) ==
+ sizeof (gpointer));
if (entry->is_reply) {
/* Request is finished, it is safe to free a connection */
}
else {
if (entry->rt->default_fs_path == NULL ||
- !rspamd_http_router_try_file (entry, msg, TRUE)) {
+ !rspamd_http_router_try_file (entry, msg, TRUE)) {
err = g_error_new (HTTP_ERROR, 404,
"Not found");
if (entry->rt->error_handler != NULL) {
err_msg->code = err->code;
err_msg->body = g_string_new (err->message);
rspamd_http_connection_reset (entry->conn);
- rspamd_http_connection_write_message (entry->conn, err_msg, NULL,
- "text/plain", entry, entry->conn->fd,
- entry->rt->ptv, entry->rt->ev_base);
+ rspamd_http_connection_write_message (entry->conn,
+ err_msg,
+ NULL,
+ "text/plain",
+ entry,
+ entry->conn->fd,
+ entry->rt->ptv,
+ entry->rt->ev_base);
g_error_free (err);
}
}
return 0;
}
-struct rspamd_http_connection_router*
+struct rspamd_http_connection_router *
rspamd_http_router_new (rspamd_http_router_error_handler_t eh,
- rspamd_http_router_finish_handler_t fh,
- struct timeval *timeout, struct event_base *base,
- const char *default_fs_path)
+ rspamd_http_router_finish_handler_t fh,
+ struct timeval *timeout, struct event_base *base,
+ const char *default_fs_path)
{
- struct rspamd_http_connection_router* new;
+ struct rspamd_http_connection_router * new;
struct stat st;
new = g_slice_alloc (sizeof (struct rspamd_http_connection_router));
void
rspamd_http_router_add_path (struct rspamd_http_connection_router *router,
- const gchar *path, rspamd_http_router_handler_t handler)
+ const gchar *path, rspamd_http_router_handler_t handler)
{
gpointer ptr;
- G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) == sizeof (gpointer));
+ G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) ==
+ sizeof (gpointer));
if (path != NULL && handler != NULL && router != NULL) {
memcpy (&ptr, &handler, sizeof (ptr));
void
rspamd_http_router_handle_socket (struct rspamd_http_connection_router *router,
- gint fd, gpointer ud)
+ gint fd, gpointer ud)
{
struct rspamd_http_connection_entry *conn;
conn->ud = ud;
conn->is_reply = FALSE;
- conn->conn = rspamd_http_connection_new (NULL, rspamd_http_router_error_handler,
- rspamd_http_router_finish_handler, 0, RSPAMD_HTTP_SERVER);
+ conn->conn = rspamd_http_connection_new (NULL,
+ rspamd_http_router_error_handler,
+ rspamd_http_router_finish_handler,
+ 0,
+ RSPAMD_HTTP_SERVER);
rspamd_http_connection_read_message (conn->conn, conn, fd, router->ptv,
- router->ev_base);
+ router->ev_base);
LL_PREPEND (router->conns, conn);
}
struct rspamd_http_connection_entry *conn, *tmp;
if (router) {
- LL_FOREACH_SAFE (router->conns, conn, tmp) {
+ LL_FOREACH_SAFE (router->conns, conn, tmp)
+ {
rspamd_http_entry_free (conn);
}
* Options for HTTP connection
*/
enum rspamd_http_options {
- RSPAMD_HTTP_BODY_PARTIAL = 0x1//!< RSPAMD_HTTP_BODY_PARTIAL
+ RSPAMD_HTTP_BODY_PARTIAL = 0x1 //!< RSPAMD_HTTP_BODY_PARTIAL
};
struct rspamd_http_connection_private;
struct rspamd_http_connection_entry;
typedef int (*rspamd_http_body_handler_t) (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg,
- const gchar *chunk,
- gsize len);
+ struct rspamd_http_message *msg,
+ const gchar *chunk,
+ gsize len);
-typedef void (*rspamd_http_error_handler_t) (struct rspamd_http_connection *conn, GError *err);
+typedef void (*rspamd_http_error_handler_t) (struct rspamd_http_connection *conn,
+ GError *err);
typedef int (*rspamd_http_finish_handler_t) (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg);
+ struct rspamd_http_message *msg);
-typedef int (*rspamd_http_router_handler_t) (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg);
-typedef void (*rspamd_http_router_error_handler_t) (struct rspamd_http_connection_entry *conn_ent,
- GError *err);
-typedef void (*rspamd_http_router_finish_handler_t) (struct rspamd_http_connection_entry *conn_ent);
+typedef int (*rspamd_http_router_handler_t) (struct rspamd_http_connection_entry
+ *conn_ent,
+ struct rspamd_http_message *msg);
+typedef void (*rspamd_http_router_error_handler_t) (struct
+ rspamd_http_connection_entry *conn_ent,
+ GError *err);
+typedef void (*rspamd_http_router_finish_handler_t) (struct
+ rspamd_http_connection_entry *conn_ent);
/**
* HTTP connection structure
* @param opts options
* @return new connection structure
*/
-struct rspamd_http_connection* rspamd_http_connection_new (
- rspamd_http_body_handler_t body_handler,
- rspamd_http_error_handler_t error_handler,
- rspamd_http_finish_handler_t finish_handler,
- enum rspamd_http_options opts,
- enum rspamd_http_connection_type type);
+struct rspamd_http_connection * rspamd_http_connection_new (
+ rspamd_http_body_handler_t body_handler,
+ rspamd_http_error_handler_t error_handler,
+ rspamd_http_finish_handler_t finish_handler,
+ enum rspamd_http_options opts,
+ enum rspamd_http_connection_type type);
/**
* Handle a request using socket fd and user data ud
* @param fd fd to read/write
*/
void rspamd_http_connection_read_message (
- struct rspamd_http_connection *conn,
- gpointer ud,
- gint fd,
- struct timeval *timeout,
- struct event_base *base);
+ struct rspamd_http_connection *conn,
+ gpointer ud,
+ gint fd,
+ struct timeval *timeout,
+ struct event_base *base);
/**
* Send reply using initialised connection
* @param fd fd to read/write
*/
void rspamd_http_connection_write_message (
- struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg,
- const gchar *host,
- const gchar *mime_type,
- gpointer ud,
- gint fd,
- struct timeval *timeout,
- struct event_base *base);
+ struct rspamd_http_connection *conn,
+ struct rspamd_http_message *msg,
+ const gchar *host,
+ const gchar *mime_type,
+ gpointer ud,
+ gint fd,
+ struct timeval *timeout,
+ struct event_base *base);
/**
* Free connection structure
static inline struct rspamd_http_connection *
rspamd_http_connection_ref (struct rspamd_http_connection *conn)
{
- conn->ref ++;
+ conn->ref++;
return conn;
}
* @param code code to pass
* @return new reply object
*/
-struct rspamd_http_message* rspamd_http_new_message (enum http_parser_type type);
+struct rspamd_http_message * rspamd_http_new_message (enum http_parser_type type);
/**
* Append a header to reply
* @param name
* @param value
*/
-void rspamd_http_message_add_header (struct rspamd_http_message *rep, const gchar *name, const gchar *value);
+void rspamd_http_message_add_header (struct rspamd_http_message *rep,
+ const gchar *name,
+ const gchar *value);
/**
* Search for a specified header in message
* @param rep message
* @param name name of header
*/
-const gchar* rspamd_http_message_find_header (struct rspamd_http_message *rep, const gchar *name);
+const gchar * rspamd_http_message_find_header (struct rspamd_http_message *rep,
+ const gchar *name);
/**
* Free HTTP reply
* the specified directory
* @return
*/
-struct rspamd_http_connection_router* rspamd_http_router_new (
- rspamd_http_router_error_handler_t eh,
- rspamd_http_router_finish_handler_t fh,
- struct timeval *timeout,
- struct event_base *base,
- const char *default_fs_path);
+struct rspamd_http_connection_router * rspamd_http_router_new (
+ rspamd_http_router_error_handler_t eh,
+ rspamd_http_router_finish_handler_t fh,
+ struct timeval *timeout,
+ struct event_base *base,
+ const char *default_fs_path);
/**
* Add new path to the router
*/
void rspamd_http_router_add_path (struct rspamd_http_connection_router *router,
- const gchar *path, rspamd_http_router_handler_t handler);
+ const gchar *path, rspamd_http_router_handler_t handler);
/**
* Handle new accepted socket
* @param fd server socket
* @param ud opaque userdata
*/
-void rspamd_http_router_handle_socket (struct rspamd_http_connection_router *router,
- gint fd, gpointer ud);
+void rspamd_http_router_handle_socket (
+ struct rspamd_http_connection_router *router,
+ gint fd,
+ gpointer ud);
/**
* Free router and all connections associated
#include "config.h"
#include "logger.h"
-#include "util.h"
#include "main.h"
#include "map.h"
+#include "util.h"
/* How much message should be repeated before it is count to be repeated one */
#define REPEATS_MIN 3
* It is NOT shared between processes and is created by main process
*/
struct rspamd_logger_s {
- rspamd_log_func_t log_func;
- struct rspamd_config *cfg;
+ rspamd_log_func_t log_func;
+ struct rspamd_config *cfg;
struct {
- guint32 size;
- guint32 used;
- u_char *buf;
+ guint32 size;
+ guint32 used;
+ u_char *buf;
} io_buf;
- gint fd;
- gboolean is_buffered;
- gboolean enabled;
- gboolean is_debug;
- gboolean throttling;
- time_t throttling_time;
- sig_atomic_t do_reopen_log;
- enum rspamd_log_type type;
- pid_t pid;
- GQuark process_type;
- radix_tree_t *debug_ip;
- guint32 last_line_cksum;
- guint32 repeats;
- gchar *saved_message;
- gchar *saved_function;
- GMutex *mtx;
+ gint fd;
+ gboolean is_buffered;
+ gboolean enabled;
+ gboolean is_debug;
+ gboolean throttling;
+ time_t throttling_time;
+ sig_atomic_t do_reopen_log;
+ enum rspamd_log_type type;
+ pid_t pid;
+ GQuark process_type;
+ radix_tree_t *debug_ip;
+ guint32 last_line_cksum;
+ guint32 repeats;
+ gchar *saved_message;
+ gchar *saved_function;
+ GMutex *mtx;
};
static const gchar lf_chr = '\n';
static void
-syslog_log_function (const gchar * log_domain, const gchar *function,
- GLogLevelFlags log_level, const gchar * message,
- gboolean forced, gpointer arg);
+syslog_log_function (const gchar * log_domain, const gchar *function,
+ GLogLevelFlags log_level, const gchar * message,
+ gboolean forced, gpointer arg);
static void
-file_log_function (const gchar * log_domain, const gchar *function,
- GLogLevelFlags log_level, const gchar * message,
- gboolean forced, gpointer arg);
+file_log_function (const gchar * log_domain, const gchar *function,
+ GLogLevelFlags log_level, const gchar * message,
+ gboolean forced, gpointer arg);
/**
* Calculate checksum for log line (used for repeating logic)
static inline guint32
rspamd_log_calculate_cksum (const gchar *message, size_t mlen)
{
- const gchar *bp = message;
- const gchar *be = bp + mlen;
- guint32 hval = 0;
-
- while (bp < be) {
- hval += (hval<<1) + (hval<<4) + (hval<<7) + (hval<<8) + (hval<<24);
- hval ^= (guint32)*bp++;
- }
-
- /* return our new hash value */
- return hval;
-
+ const gchar *bp = message;
+ const gchar *be = bp + mlen;
+ guint32 hval = 0;
+
+ while (bp < be) {
+ hval +=
+ (hval <<
+ 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
+ hval ^= (guint32) * bp++;
+ }
+
+ /* return our new hash value */
+ return hval;
+
}
/*
* Write a line to log file (unbuffered)
*/
static void
-direct_write_log_line (rspamd_logger_t *rspamd_log, void *data, gint count, gboolean is_iov)
+direct_write_log_line (rspamd_logger_t *rspamd_log,
+ void *data,
+ gint count,
+ gboolean is_iov)
{
- gchar errmsg[128];
- struct iovec *iov;
- const gchar *line;
- gint r;
-
+ gchar errmsg[128];
+ struct iovec *iov;
+ const gchar *line;
+ gint r;
+
if (rspamd_log->enabled) {
if (is_iov) {
iov = (struct iovec *)data;
}
if (r == -1) {
/* We cannot write message to file, so we need to detect error and make decision */
- r = rspamd_snprintf (errmsg, sizeof (errmsg), "direct_write_log_line: cannot write log line: %s", strerror (errno));
+ r = rspamd_snprintf (errmsg,
+ sizeof (errmsg),
+ "direct_write_log_line: cannot write log line: %s",
+ strerror (errno));
if (errno == EIO || errno == EINTR) {
/* Descriptor is somehow invalid, try to restart */
reopen_log (rspamd_log);
direct_write_log_line (rspamd_log, data, count, is_iov);
}
}
- else if (errno == EFAULT || errno == EINVAL || errno == EFBIG || errno == ENOSPC) {
+ else if (errno == EFAULT || errno == EINVAL || errno == EFBIG ||
+ errno == ENOSPC) {
/* Rare case */
rspamd_log->throttling = TRUE;
rspamd_log->throttling_time = time (NULL);
else if (*p == '\n' || *p == '\r') {
*p = ' ';
}
- p ++;
+ p++;
}
}
rspamd_log->enabled = TRUE;
return 0;
case RSPAMD_LOG_FILE:
- rspamd_log->fd = open (rspamd_log->cfg->log_file, O_CREAT | O_WRONLY | O_APPEND,
+ rspamd_log->fd = open (rspamd_log->cfg->log_file,
+ O_CREAT | O_WRONLY | O_APPEND,
S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
if (rspamd_log->fd == -1) {
fprintf (stderr, "open_log: cannot open desired log file: %s, %s",
- rspamd_log->cfg->log_file, strerror (errno));
+ rspamd_log->cfg->log_file, strerror (errno));
return -1;
}
if (fchown (rspamd_log->fd, uid, gid) == -1) {
fprintf (stderr, "open_log: cannot chown desired log file: %s, %s",
- rspamd_log->cfg->log_file, strerror (errno));
+ rspamd_log->cfg->log_file, strerror (errno));
close (rspamd_log->fd);
return -1;
}
void
close_log_priv (rspamd_logger_t *rspamd_log, uid_t uid, gid_t gid)
{
- gchar tmpbuf[256];
+ gchar tmpbuf[256];
flush_log_buf (rspamd_log);
switch (rspamd_log->type) {
case RSPAMD_LOG_FILE:
if (rspamd_log->enabled) {
if (rspamd_log->repeats > REPEATS_MIN) {
- rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats);
+ rspamd_snprintf (tmpbuf,
+ sizeof (tmpbuf),
+ "Last message repeated %ud times",
+ rspamd_log->repeats);
rspamd_log->repeats = 0;
if (rspamd_log->saved_message) {
- file_log_function (NULL, rspamd_log->saved_function, rspamd_log->cfg->log_level, rspamd_log->saved_message, TRUE, rspamd_log);
+ file_log_function (NULL,
+ rspamd_log->saved_function,
+ rspamd_log->cfg->log_level,
+ rspamd_log->saved_message,
+ TRUE,
+ rspamd_log);
g_free (rspamd_log->saved_message);
g_free (rspamd_log->saved_function);
rspamd_log->saved_message = NULL;
rspamd_log->saved_function = NULL;
- }
+ }
/* It is safe to use temporary buffer here as it is not static */
- file_log_function (NULL, __FUNCTION__, rspamd_log->cfg->log_level, tmpbuf, TRUE, rspamd_log);
+ file_log_function (NULL,
+ __FUNCTION__,
+ rspamd_log->cfg->log_level,
+ tmpbuf,
+ TRUE,
+ rspamd_log);
return;
}
* Setup logger
*/
void
-rspamd_set_logger (struct rspamd_config *cfg, GQuark ptype, struct rspamd_main *rspamd)
+rspamd_set_logger (struct rspamd_config *cfg,
+ GQuark ptype,
+ struct rspamd_main *rspamd)
{
- gchar **strvec, *p, *err;
- gint num, i, k;
- struct in_addr addr;
- guint32 mask = 0xFFFFFFFF;
+ gchar **strvec, *p, *err;
+ gint num, i, k;
+ struct in_addr addr;
+ guint32 mask = 0xFFFFFFFF;
if (rspamd->logger == NULL) {
rspamd->logger = g_malloc (sizeof (rspamd_logger_t));
#endif
switch (cfg->log_type) {
- case RSPAMD_LOG_CONSOLE:
- rspamd->logger->log_func = file_log_function;
- rspamd->logger->fd = STDERR_FILENO;
- break;
- case RSPAMD_LOG_SYSLOG:
- rspamd->logger->log_func = syslog_log_function;
- break;
- case RSPAMD_LOG_FILE:
- rspamd->logger->log_func = file_log_function;
- break;
+ case RSPAMD_LOG_CONSOLE:
+ rspamd->logger->log_func = file_log_function;
+ rspamd->logger->fd = STDERR_FILENO;
+ break;
+ case RSPAMD_LOG_SYSLOG:
+ rspamd->logger->log_func = syslog_log_function;
+ break;
+ case RSPAMD_LOG_FILE:
+ rspamd->logger->log_func = file_log_function;
+ break;
}
rspamd->logger->cfg = cfg;
radix_tree_free (rspamd->logger->debug_ip);
}
rspamd->logger->debug_ip = radix_tree_create ();
- if (!add_map (rspamd->cfg, rspamd->cfg->debug_ip_map, "IP addresses for which debug logs are enabled",
- read_radix_list, fin_radix_list, (void **)&rspamd->logger->debug_ip)) {
+ if (!add_map (rspamd->cfg, rspamd->cfg->debug_ip_map,
+ "IP addresses for which debug logs are enabled",
+ read_radix_list, fin_radix_list,
+ (void **)&rspamd->logger->debug_ip)) {
/* Try to parse it as list */
strvec = g_strsplit_set (rspamd->cfg->debug_ip_map, ",; ", 0);
num = g_strv_length (strvec);
if ((p = strchr (strvec[i], '/')) != NULL) {
/* Try to extract mask */
*p = '\0';
- p ++;
+ p++;
errno = 0;
k = strtoul (p, &err, 10);
if (errno != 0 || *err != '\0' || k > 32) {
if (inet_aton (strvec[i], &addr)) {
/* Check ip */
mask = mask << (32 - k);
- radix32tree_insert (rspamd->logger->debug_ip, ntohl (addr.s_addr), mask, 1);
+ radix32tree_insert (rspamd->logger->debug_ip,
+ ntohl (addr.s_addr), mask, 1);
}
}
g_strfreev (strvec);
void
flush_log_buf (rspamd_logger_t *rspamd_log)
{
- if (rspamd_log->is_buffered && (rspamd_log->type == RSPAMD_LOG_CONSOLE || rspamd_log->type == RSPAMD_LOG_FILE)) {
- direct_write_log_line (rspamd_log, rspamd_log->io_buf.buf, rspamd_log->io_buf.used, FALSE);
+ if (rspamd_log->is_buffered &&
+ (rspamd_log->type == RSPAMD_LOG_CONSOLE || rspamd_log->type ==
+ RSPAMD_LOG_FILE)) {
+ direct_write_log_line (rspamd_log,
+ rspamd_log->io_buf.buf,
+ rspamd_log->io_buf.used,
+ FALSE);
rspamd_log->io_buf.used = 0;
}
}
void
-rspamd_common_logv (rspamd_logger_t *rspamd_log, GLogLevelFlags log_level, const gchar *function,
- const gchar *fmt, va_list args)
+rspamd_common_logv (rspamd_logger_t *rspamd_log,
+ GLogLevelFlags log_level,
+ const gchar *function,
+ const gchar *fmt,
+ va_list args)
{
- static gchar logbuf[BUFSIZ];
- u_char *end;
+ static gchar logbuf[BUFSIZ];
+ u_char *end;
if (rspamd_log == NULL) {
rspamd_log = default_logger;
end = rspamd_vsnprintf (logbuf, sizeof (logbuf), fmt, args);
*end = '\0';
rspamd_escape_log_string (logbuf);
- rspamd_log->log_func (NULL, function, log_level, logbuf, FALSE, rspamd_log);
+ rspamd_log->log_func (NULL,
+ function,
+ log_level,
+ logbuf,
+ FALSE,
+ rspamd_log);
g_mutex_unlock (rspamd_log->mtx);
}
}
* This log functions select real logger and write message if level is less or equal to configured log level
*/
void
-rspamd_common_log_function (rspamd_logger_t *rspamd_log, GLogLevelFlags log_level,
- const gchar *function, const gchar *fmt, ...)
+rspamd_common_log_function (rspamd_logger_t *rspamd_log,
+ GLogLevelFlags log_level,
+ const gchar *function,
+ const gchar *fmt,
+ ...)
{
- va_list vp;
+ va_list vp;
va_start (vp, fmt);
rspamd_common_logv (rspamd_log, log_level, function, fmt, vp);
void
rspamd_default_logv (GLogLevelFlags log_level, const gchar *function,
- const gchar *fmt, va_list args)
+ const gchar *fmt, va_list args)
{
rspamd_common_logv (NULL, log_level, function, fmt, args);
}
void
rspamd_default_log_function (GLogLevelFlags log_level,
- const gchar *function, const gchar *fmt, ...)
+ const gchar *function, const gchar *fmt, ...)
{
- va_list vp;
+ va_list vp;
va_start (vp, fmt);
rspamd_default_logv (log_level, function, fmt, vp);
static void
fill_buffer (rspamd_logger_t *rspamd_log, const struct iovec *iov, gint iovcnt)
{
- gint i;
+ gint i;
- for (i = 0; i < iovcnt; i ++) {
- memcpy (rspamd_log->io_buf.buf + rspamd_log->io_buf.used, iov[i].iov_base, iov[i].iov_len);
+ for (i = 0; i < iovcnt; i++) {
+ memcpy (rspamd_log->io_buf.buf + rspamd_log->io_buf.used,
+ iov[i].iov_base,
+ iov[i].iov_len);
rspamd_log->io_buf.used += iov[i].iov_len;
}
* Write message to buffer or to file (using direct_write_log_line function)
*/
static void
-file_log_helper (rspamd_logger_t *rspamd_log, const struct iovec *iov, gint iovcnt)
+file_log_helper (rspamd_logger_t *rspamd_log,
+ const struct iovec *iov,
+ gint iovcnt)
{
- size_t len = 0;
- gint i;
+ size_t len = 0;
+ gint i;
- if (! rspamd_log->is_buffered) {
+ if (!rspamd_log->is_buffered) {
/* Write string directly */
direct_write_log_line (rspamd_log, (void *)iov, iovcnt, TRUE);
}
else {
/* Calculate total length */
- for (i = 0; i < iovcnt; i ++) {
+ for (i = 0; i < iovcnt; i++) {
len += iov[i].iov_len;
}
/* Fill buffer */
* Syslog interface for logging
*/
static void
-syslog_log_function (const gchar * log_domain, const gchar *function, GLogLevelFlags log_level, const gchar * message, gboolean forced, gpointer arg)
+syslog_log_function (const gchar * log_domain,
+ const gchar *function,
+ GLogLevelFlags log_level,
+ const gchar * message,
+ gboolean forced,
+ gpointer arg)
{
- rspamd_logger_t *rspamd_log = arg;
+ rspamd_logger_t *rspamd_log = arg;
- if (! rspamd_log->enabled) {
+ if (!rspamd_log->enabled) {
return;
}
if (function == NULL) {
* Main file interface for logging
*/
static void
-file_log_function (const gchar * log_domain, const gchar *function, GLogLevelFlags log_level, const gchar * message, gboolean forced, gpointer arg)
+file_log_function (const gchar * log_domain,
+ const gchar *function,
+ GLogLevelFlags log_level,
+ const gchar * message,
+ gboolean forced,
+ gpointer arg)
{
- gchar tmpbuf[256], timebuf[32];
- time_t now;
- struct tm *tms;
- struct iovec iov[4];
- gint r = 0;
- guint32 cksum;
- size_t mlen;
- const gchar *cptype = NULL;
- gboolean got_time = FALSE;
- rspamd_logger_t *rspamd_log = arg;
-
- if (! rspamd_log->enabled) {
+ gchar tmpbuf[256], timebuf[32];
+ time_t now;
+ struct tm *tms;
+ struct iovec iov[4];
+ gint r = 0;
+ guint32 cksum;
+ size_t mlen;
+ const gchar *cptype = NULL;
+ gboolean got_time = FALSE;
+ rspamd_logger_t *rspamd_log = arg;
+
+ if (!rspamd_log->enabled) {
return;
}
mlen = strlen (message);
cksum = rspamd_log_calculate_cksum (message, mlen);
if (cksum == rspamd_log->last_line_cksum) {
- rspamd_log->repeats ++;
- if (rspamd_log->repeats > REPEATS_MIN && rspamd_log->repeats < REPEATS_MAX) {
+ rspamd_log->repeats++;
+ if (rspamd_log->repeats > REPEATS_MIN && rspamd_log->repeats <
+ REPEATS_MAX) {
/* Do not log anything */
if (rspamd_log->saved_message == 0) {
rspamd_log->saved_message = g_strdup (message);
return;
}
else if (rspamd_log->repeats > REPEATS_MAX) {
- rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats);
+ rspamd_snprintf (tmpbuf,
+ sizeof (tmpbuf),
+ "Last message repeated %ud times",
+ rspamd_log->repeats);
rspamd_log->repeats = 0;
/* It is safe to use temporary buffer here as it is not static */
if (rspamd_log->saved_message) {
- file_log_function (log_domain, rspamd_log->saved_function, log_level, rspamd_log->saved_message, forced, arg);
- }
- file_log_function (log_domain, __FUNCTION__, log_level, tmpbuf, forced, arg);
- file_log_function (log_domain, function, log_level, message, forced, arg);
+ file_log_function (log_domain,
+ rspamd_log->saved_function,
+ log_level,
+ rspamd_log->saved_message,
+ forced,
+ arg);
+ }
+ file_log_function (log_domain,
+ __FUNCTION__,
+ log_level,
+ tmpbuf,
+ forced,
+ arg);
+ file_log_function (log_domain,
+ function,
+ log_level,
+ message,
+ forced,
+ arg);
rspamd_log->repeats = REPEATS_MIN + 1;
return;
}
/* Reset counter if new message differs from saved message */
rspamd_log->last_line_cksum = cksum;
if (rspamd_log->repeats > REPEATS_MIN) {
- rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats);
+ rspamd_snprintf (tmpbuf,
+ sizeof (tmpbuf),
+ "Last message repeated %ud times",
+ rspamd_log->repeats);
rspamd_log->repeats = 0;
if (rspamd_log->saved_message) {
- file_log_function (log_domain, rspamd_log->saved_function, log_level, rspamd_log->saved_message, forced, arg);
+ file_log_function (log_domain,
+ rspamd_log->saved_function,
+ log_level,
+ rspamd_log->saved_message,
+ forced,
+ arg);
g_free (rspamd_log->saved_message);
g_free (rspamd_log->saved_function);
rspamd_log->saved_message = NULL;
rspamd_log->saved_function = NULL;
- }
- file_log_function (log_domain, __FUNCTION__, log_level, tmpbuf, forced, arg);
+ }
+ file_log_function (log_domain,
+ __FUNCTION__,
+ log_level,
+ tmpbuf,
+ forced,
+ arg);
/* It is safe to use temporary buffer here as it is not static */
- file_log_function (log_domain, function, log_level, message, forced, arg);
+ file_log_function (log_domain,
+ function,
+ log_level,
+ message,
+ forced,
+ arg);
return;
}
else {
}
if (rspamd_log->cfg->log_extended) {
- if (! got_time) {
+ if (!got_time) {
now = time (NULL);
}
r = 0;
}
if (function == NULL) {
- r += rspamd_snprintf (tmpbuf + r, sizeof (tmpbuf) - r, "%s #%P(%s) ", timebuf, rspamd_log->pid, cptype);
+ r += rspamd_snprintf (tmpbuf + r,
+ sizeof (tmpbuf) - r,
+ "%s #%P(%s) ",
+ timebuf,
+ rspamd_log->pid,
+ cptype);
}
else {
- r += rspamd_snprintf (tmpbuf + r, sizeof (tmpbuf) -r, "%s #%P(%s) %s: ", timebuf, rspamd_log->pid, cptype, function);
+ r += rspamd_snprintf (tmpbuf + r,
+ sizeof (tmpbuf) - r,
+ "%s #%P(%s) %s: ",
+ timebuf,
+ rspamd_log->pid,
+ cptype,
+ function);
}
/* Construct IOV for log line */
iov[0].iov_base = tmpbuf;
*/
void
rspamd_conditional_debug (rspamd_logger_t *rspamd_log,
- rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...)
+ rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...)
{
- static gchar logbuf[BUFSIZ];
- va_list vp;
- u_char *end;
+ static gchar logbuf[BUFSIZ];
+ va_list vp;
+ u_char *end;
- if (rspamd_log->cfg->log_level >= G_LOG_LEVEL_DEBUG || rspamd_log->is_debug) {
+ if (rspamd_log->cfg->log_level >= G_LOG_LEVEL_DEBUG ||
+ rspamd_log->is_debug) {
if (rspamd_log->debug_ip && addr != NULL) {
if (addr->af == AF_INET && radix32tree_find (rspamd_log->debug_ip,
- ntohl (addr->addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
+ ntohl (addr->addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
return;
}
}
*end = '\0';
rspamd_escape_log_string (logbuf);
va_end (vp);
- rspamd_log->log_func (NULL, function, G_LOG_LEVEL_DEBUG, logbuf, TRUE, rspamd_log);
+ rspamd_log->log_func (NULL,
+ function,
+ G_LOG_LEVEL_DEBUG,
+ logbuf,
+ TRUE,
+ rspamd_log);
g_mutex_unlock (rspamd_log->mtx);
}
-}
+}
/**
* Wrapper for glib logger
*/
void
-rspamd_glib_log_function (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer arg)
+rspamd_glib_log_function (const gchar *log_domain,
+ GLogLevelFlags log_level,
+ const gchar *message,
+ gpointer arg)
{
- rspamd_logger_t *rspamd_log = arg;
+ rspamd_logger_t *rspamd_log = arg;
if (rspamd_log->enabled) {
g_mutex_lock (rspamd_log->mtx);
- rspamd_log->log_func (log_domain, NULL, log_level, message, FALSE, rspamd_log);
+ rspamd_log->log_func (log_domain,
+ NULL,
+ log_level,
+ message,
+ FALSE,
+ rspamd_log);
g_mutex_unlock (rspamd_log->mtx);
}
}
#ifndef RSPAMD_LOGGER_H
#define RSPAMD_LOGGER_H
-#include "config.h"
#include "cfg_file.h"
+#include "config.h"
#include "radix.h"
#include "util.h"
-typedef void (*rspamd_log_func_t)(const gchar * log_domain, const gchar *function,
- GLogLevelFlags log_level, const gchar * message,
- gboolean forced, gpointer arg);
+typedef void (*rspamd_log_func_t)(const gchar * log_domain,
+ const gchar *function,
+ GLogLevelFlags log_level, const gchar * message,
+ gboolean forced, gpointer arg);
typedef struct rspamd_logger_s rspamd_logger_t;
/**
* Init logger
*/
-void rspamd_set_logger (struct rspamd_config *cfg, GQuark ptype, struct rspamd_main *main);
+void rspamd_set_logger (struct rspamd_config *cfg,
+ GQuark ptype,
+ struct rspamd_main *main);
/**
* Open log file or initialize other structures
*/
* Log function that is compatible for glib messages
*/
void rspamd_glib_log_function (const gchar *log_domain,
- GLogLevelFlags log_level, const gchar *message, gpointer arg);
+ GLogLevelFlags log_level, const gchar *message, gpointer arg);
/**
* Function with variable number of arguments support
*/
void rspamd_common_log_function (rspamd_logger_t *logger,
- GLogLevelFlags log_level, const gchar *function, const gchar *fmt, ...);
+ GLogLevelFlags log_level, const gchar *function, const gchar *fmt, ...);
void rspamd_common_logv (rspamd_logger_t *logger,
- GLogLevelFlags log_level, const gchar *function, const gchar *fmt, va_list args);
+ GLogLevelFlags log_level,
+ const gchar *function,
+ const gchar *fmt,
+ va_list args);
/**
* Conditional debug function
*/
void rspamd_conditional_debug (rspamd_logger_t *logger,
- rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...) ;
+ rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...);
/**
* Function with variable number of arguments support that uses static default logger
*/
-void rspamd_default_log_function (GLogLevelFlags log_level, const gchar *function,
- const gchar *fmt, ...);
+void rspamd_default_log_function (GLogLevelFlags log_level,
+ const gchar *function,
+ const gchar *fmt,
+ ...);
/**
* Varargs version of default log function
* @param fmt
* @param args
*/
-void rspamd_default_logv (GLogLevelFlags log_level, const gchar *function, const gchar *fmt, va_list args);
+void rspamd_default_logv (GLogLevelFlags log_level,
+ const gchar *function,
+ const gchar *fmt,
+ va_list args);
/**
* Temporary turn on debug
/* Logging in postfix style */
#if defined(RSPAMD_MAIN)
-#define msg_err(...) rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_CRITICAL, __FUNCTION__, __VA_ARGS__)
-#define msg_warn(...) rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_WARNING, __FUNCTION__, __VA_ARGS__)
-#define msg_info(...) rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_INFO, __FUNCTION__, __VA_ARGS__)
-#define msg_debug(...) rspamd_conditional_debug(rspamd_main->logger, NULL, __FUNCTION__, __VA_ARGS__)
-#define debug_task(...) rspamd_conditional_debug(rspamd_main->logger, &task->from_addr, __FUNCTION__, __VA_ARGS__)
+#define msg_err(...) rspamd_common_log_function (rspamd_main->logger, \
+ G_LOG_LEVEL_CRITICAL, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define msg_warn(...) rspamd_common_log_function (rspamd_main->logger, \
+ G_LOG_LEVEL_WARNING, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define msg_info(...) rspamd_common_log_function (rspamd_main->logger, \
+ G_LOG_LEVEL_INFO, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define msg_debug(...) rspamd_conditional_debug (rspamd_main->logger, \
+ NULL, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define debug_task(...) rspamd_conditional_debug (rspamd_main->logger, \
+ &task->from_addr, \
+ __FUNCTION__, \
+ __VA_ARGS__)
#else
-#define msg_err(...) rspamd_default_log_function(G_LOG_LEVEL_CRITICAL, __FUNCTION__, __VA_ARGS__)
-#define msg_warn(...) rspamd_default_log_function(G_LOG_LEVEL_WARNING, __FUNCTION__, __VA_ARGS__)
-#define msg_info(...) rspamd_default_log_function(G_LOG_LEVEL_INFO, __FUNCTION__, __VA_ARGS__)
-#define msg_debug(...) rspamd_default_log_function(G_LOG_LEVEL_DEBUG, __FUNCTION__, __VA_ARGS__)
-#define debug_task(...) rspamd_default_log_function(G_LOG_LEVEL_DEBUG, __FUNCTION__, __VA_ARGS__)
+#define msg_err(...) rspamd_default_log_function (G_LOG_LEVEL_CRITICAL, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define msg_warn(...) rspamd_default_log_function (G_LOG_LEVEL_WARNING, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define msg_info(...) rspamd_default_log_function (G_LOG_LEVEL_INFO, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define msg_debug(...) rspamd_default_log_function (G_LOG_LEVEL_DEBUG, \
+ __FUNCTION__, \
+ __VA_ARGS__)
+#define debug_task(...) rspamd_default_log_function (G_LOG_LEVEL_DEBUG, \
+ __FUNCTION__, \
+ __VA_ARGS__)
#endif
#endif
* Implementation of map files handling
*/
#include "config.h"
-#include "map.h"
#include "http.h"
#include "main.h"
-#include "util.h"
+#include "map.h"
#include "mem_pool.h"
+#include "util.h"
-static const gchar *hash_fill = "1";
+static const gchar *hash_fill = "1";
/* Http reply */
struct http_reply {
- gint code;
- GHashTable *headers;
- gchar *cur_header;
- gint parser_state;
+ gint code;
+ GHashTable *headers;
+ gchar *cur_header;
+ gint parser_state;
};
struct http_callback_data {
- struct event ev;
- struct event_base *ev_base;
- struct timeval tv;
- struct rspamd_map *map;
- struct http_map_data *data;
- struct http_reply *reply;
- struct map_cb_data cbdata;
-
- gint state;
- gint fd;
+ struct event ev;
+ struct event_base *ev_base;
+ struct timeval tv;
+ struct rspamd_map *map;
+ struct http_map_data *data;
+ struct http_reply *reply;
+ struct map_cb_data cbdata;
+
+ gint state;
+ gint fd;
};
/* Value in seconds after whitch we would try to do stat on list file */
* Helper for HTTP connection establishment
*/
static gint
-connect_http (struct rspamd_map *map, struct http_map_data *data, gboolean is_async)
+connect_http (struct rspamd_map *map,
+ struct http_map_data *data,
+ gboolean is_async)
{
- gint sock;
+ gint sock;
if ((sock = make_tcp_socket (data->addr, FALSE, is_async)) == -1) {
- msg_info ("cannot connect to http server %s: %d, %s", data->host, errno, strerror (errno));
+ msg_info ("cannot connect to http server %s: %d, %s",
+ data->host,
+ errno,
+ strerror (errno));
return -1;
}
* Write HTTP request
*/
static void
-write_http_request (struct rspamd_map *map, struct http_map_data *data, gint sock)
+write_http_request (struct rspamd_map *map,
+ struct http_map_data *data,
+ gint sock)
{
- gchar outbuf[BUFSIZ], datebuf[128];
- gint r;
- struct tm *tm;
+ gchar outbuf[BUFSIZ], datebuf[128];
+ gint r;
+ struct tm *tm;
tm = gmtime (&data->last_checked);
strftime (datebuf, sizeof (datebuf), "%a, %d %b %Y %H:%M:%S %Z", tm);
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "GET %s%s HTTP/1.1" CRLF "Connection: close" CRLF "Host: %s" CRLF, (*data->path == '/') ? "" : "/", data->path, data->host);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "GET %s%s HTTP/1.1" CRLF "Connection: close" CRLF "Host: %s" CRLF,
+ (*data->path == '/') ? "" : "/",
+ data->path,
+ data->host);
if (data->last_checked != 0) {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "If-Modified-Since: %s" CRLF, datebuf);
+ r += rspamd_snprintf (outbuf + r,
+ sizeof (outbuf) - r,
+ "If-Modified-Since: %s" CRLF,
+ datebuf);
}
r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, CRLF);
/**
* FSM for parsing HTTP reply
*/
-static gchar *
+static gchar *
parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
{
- gchar *s, *p, *err_str, *tmp;
+ gchar *s, *p, *err_str, *tmp;
p = chunk;
s = chunk;
while (p - chunk < len) {
switch (reply->parser_state) {
- /* Search status code */
+ /* Search status code */
case 0:
/* Search for status code */
if (*p != ' ') {
continue;
}
break;
- /* Skip to end of line */
+ /* Skip to end of line */
case 1:
if (*p == '\n') {
/* Switch to read header state */
/* Each skipped symbol is proceeded */
s = ++p;
break;
- /* Read header value */
+ /* Read header value */
case 2:
if (*p == ':') {
reply->cur_header = g_malloc (p - s + 1);
}
p++;
break;
- /* Skip spaces after header name */
+ /* Skip spaces after header name */
case 3:
if (*p != ' ') {
s = p;
p++;
}
break;
- /* Read header value */
+ /* Read header value */
case 4:
if (*p == '\r') {
if (reply->cur_header != NULL) {
tmp = g_malloc (p - s + 1);
rspamd_strlcpy (tmp, s, p - s + 1);
- g_hash_table_insert (reply->headers, reply->cur_header, tmp);
+ g_hash_table_insert (reply->headers, reply->cur_header,
+ tmp);
reply->cur_header = NULL;
}
reply->parser_state = 1;
static gint
read_chunk_header (gchar * buf, gint len, struct http_map_data *data)
{
- gchar chunkbuf[32], *p, *c, *err_str;
- gint skip = 0;
+ gchar chunkbuf[32], *p, *c, *err_str;
+ gint skip = 0;
p = chunkbuf;
c = buf;
/* Find hex digits */
- while (g_ascii_isxdigit (*c) && p - chunkbuf < (gint)(sizeof (chunkbuf) - 1) && skip < len) {
+ while (g_ascii_isxdigit (*c) && p - chunkbuf <
+ (gint)(sizeof (chunkbuf) - 1) && skip < len) {
*p++ = *c++;
skip++;
}
/**
* Helper callback for reading chunked reply
*/
-static gboolean
-read_http_chunked (gchar * buf, size_t len, struct rspamd_map *map, struct http_map_data *data, struct map_cb_data *cbdata)
+static gboolean
+read_http_chunked (gchar * buf,
+ size_t len,
+ struct rspamd_map *map,
+ struct http_map_data *data,
+ struct map_cb_data *cbdata)
{
- gchar *p = buf, *remain;
- gint skip = 0;
+ gchar *p = buf, *remain;
+ gint skip = 0;
if (data->chunked == 1) {
/* Read first chunk data */
/**
* Callback for reading HTTP reply
*/
-static gboolean
-read_http_common (struct rspamd_map *map, struct http_map_data *data, struct http_reply *reply, struct map_cb_data *cbdata, gint fd)
+static gboolean
+read_http_common (struct rspamd_map *map,
+ struct http_map_data *data,
+ struct http_reply *reply,
+ struct map_cb_data *cbdata,
+ gint fd)
{
- gchar *remain, *pos;
- ssize_t r;
- gchar *te, *date;
-
- if ((r = read (fd, data->read_buf + data->rlen, sizeof (data->read_buf) - data->rlen)) > 0) {
+ gchar *remain, *pos;
+ ssize_t r;
+ gchar *te, *date;
+
+ if ((r =
+ read (fd, data->read_buf + data->rlen, sizeof (data->read_buf) -
+ data->rlen)) > 0) {
r += data->rlen;
data->rlen = 0;
remain = parse_http_reply (data->read_buf, r, reply);
if (reply->parser_state == 6) {
/* If reply header is parsed successfully, try to read further data */
if (reply->code != 200 && reply->code != 304) {
- msg_err ("got error reply from server %s, %d", data->host, reply->code);
+ msg_err ("got error reply from server %s, %d",
+ data->host,
+ reply->code);
return FALSE;
}
else if (reply->code == 304) {
pos = data->read_buf;
/* Check for chunked */
if (data->chunked == 0) {
- if ((te = g_hash_table_lookup (reply->headers, "Transfer-Encoding")) != NULL) {
+ if ((te =
+ g_hash_table_lookup (reply->headers,
+ "Transfer-Encoding")) != NULL) {
if (g_ascii_strcasecmp (te, "chunked") == 0) {
data->chunked = 1;
}
static void
read_http_sync (struct rspamd_map *map, struct http_map_data *data)
{
- struct map_cb_data cbdata;
- gint fd;
- struct http_reply *repl;
+ struct map_cb_data cbdata;
+ gint fd;
+ struct http_reply *repl;
if (map->read_callback == NULL || map->fin_callback == NULL) {
msg_err ("bad callback for reading map file");
repl = g_malloc (sizeof (struct http_reply));
repl->parser_state = 0;
repl->code = 404;
- repl->headers = g_hash_table_new_full (rspamd_strcase_hash, rspamd_strcase_equal, g_free, g_free);
+ repl->headers = g_hash_table_new_full (rspamd_strcase_hash,
+ rspamd_strcase_equal,
+ g_free,
+ g_free);
- while (read_http_common (map, data, repl, &cbdata, fd));
+ while (read_http_common (map, data, repl, &cbdata, fd)) ;
close (fd);
static void
read_map_file (struct rspamd_map *map, struct file_map_data *data)
{
- struct map_cb_data cbdata;
- gchar buf[BUFSIZ], *remain;
- ssize_t r;
- gint fd, rlen;
+ struct map_cb_data cbdata;
+ gchar buf[BUFSIZ], *remain;
+ ssize_t r;
+ gint fd, rlen;
if (map->read_callback == NULL || map->fin_callback == NULL) {
msg_err ("bad callback for reading map file");
}
if ((fd = open (data->filename, O_RDONLY)) == -1) {
- msg_warn ("cannot open file '%s': %s", data->filename, strerror (errno));
+ msg_warn ("cannot open file '%s': %s", data->filename,
+ strerror (errno));
return;
}
/**
* FSM for parsing lists
*/
-gchar *
-abstract_parse_kv_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data, insert_func func)
+gchar *
+abstract_parse_kv_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data,
+ insert_func func)
{
- gchar *c, *p, *key = NULL, *value = NULL;
+ gchar *c, *p, *key = NULL, *value = NULL;
p = chunk;
c = p;
}
}
else {
- p ++;
+ p++;
}
break;
case 2:
data->state = 0;
}
else {
- p ++;
+ p++;
}
break;
case 99:
case 100:
/* Skip \r\n and whitespaces */
if (*p == '\r' || *p == '\n' || g_ascii_isspace (*p)) {
- p ++;
+ p++;
}
else {
c = p;
return c;
}
-gchar *
-abstract_parse_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data, insert_func func)
+gchar *
+abstract_parse_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data,
+ insert_func func)
{
- gchar *s, *p, *str, *start;
+ gchar *s, *p, *str, *start;
p = chunk;
start = p;
while (p - chunk < len) {
switch (data->state) {
- /* READ_SYMBOL */
+ /* READ_SYMBOL */
case 0:
if (*p == '#') {
/* Got comment */
p++;
}
break;
- /* SKIP_COMMENT */
+ /* SKIP_COMMENT */
case 1:
/* Skip comment till end of line */
if (*p == '\r' || *p == '\n') {
static void
radix_tree_insert_helper (gpointer st, gconstpointer key, gpointer value)
{
- radix_tree_t *tree = st;
+ radix_tree_t *tree = st;
- guint32 mask = 0xFFFFFFFF;
- guint32 ip;
- gchar *token, *ipnet, *err_str, **strv, **cur;
- struct in_addr ina;
- gint k;
+ guint32 mask = 0xFFFFFFFF;
+ guint32 ip;
+ gchar *token, *ipnet, *err_str, **strv, **cur;
+ struct in_addr ina;
+ gint k;
/* Split string if there are multiple items inside a single string */
strv = g_strsplit_set ((gchar *)key, " ,;", 0);
/* Get mask */
k = strtoul (ipnet, &err_str, 10);
if (errno != 0) {
- msg_warn ("invalid netmask, error detected on symbol: %s, erorr: %s", err_str, strerror (errno));
+ msg_warn (
+ "invalid netmask, error detected on symbol: %s, erorr: %s",
+ err_str,
+ strerror (errno));
k = 32;
}
else if (k > 32 || k < 0) {
ip = ntohl ((guint32) ina.s_addr);
k = radix32tree_insert (tree, ip, mask, 1);
if (k == -1) {
- msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (ina), mask);
+ msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (
+ ina), mask);
}
else if (k == 1) {
- msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (ina), mask);
+ msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (
+ ina), mask);
}
cur++;
}
}
/* Helpers */
-gchar *
-read_host_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+gchar *
+read_host_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
if (data->cur_data == NULL) {
- data->cur_data = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+ data->cur_data = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
}
- return abstract_parse_list (pool, chunk, len, data, (insert_func) g_hash_table_insert);
+ return abstract_parse_list (pool,
+ chunk,
+ len,
+ data,
+ (insert_func) g_hash_table_insert);
}
void
}
}
-gchar *
-read_kv_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+gchar *
+read_kv_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
if (data->cur_data == NULL) {
- data->cur_data = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+ data->cur_data = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
}
- return abstract_parse_kv_list (pool, chunk, len, data, (insert_func) g_hash_table_insert);
+ return abstract_parse_kv_list (pool,
+ chunk,
+ len,
+ data,
+ (insert_func) g_hash_table_insert);
}
void
}
}
-gchar *
-read_radix_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+gchar *
+read_radix_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
if (data->cur_data == NULL) {
data->cur_data = radix_tree_create ();
}
- return abstract_parse_list (pool, chunk, len, data, (insert_func) radix_tree_insert_helper);
+ return abstract_parse_list (pool,
+ chunk,
+ len,
+ data,
+ (insert_func) radix_tree_insert_helper);
}
void
static void
file_callback (gint fd, short what, void *ud)
{
- struct rspamd_map *map = ud;
- struct file_map_data *data = map->map_data;
- struct stat st;
- gdouble jittered_sec;
+ struct rspamd_map *map = ud;
+ struct file_map_data *data = map->map_data;
+ struct stat st;
+ gdouble jittered_sec;
/* Plan event again with jitter */
evtimer_del (&map->ev);
- jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
+ jittered_sec =
+ (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
if (g_atomic_int_get (map->locked)) {
- msg_info ("don't try to reread map as it is locked by other process, will reread it later");
+ msg_info (
+ "don't try to reread map as it is locked by other process, will reread it later");
return;
}
- if (stat (data->filename, &st) != -1 && (st.st_mtime > data->st.st_mtime || data->st.st_mtime == -1)) {
+ if (stat (data->filename,
+ &st) != -1 &&
+ (st.st_mtime > data->st.st_mtime || data->st.st_mtime == -1)) {
/* File was modified since last check */
memcpy (&data->st, &st, sizeof (struct stat));
}
static void
http_async_callback (gint fd, short what, void *ud)
{
- struct http_callback_data *cbd = ud;
+ struct http_callback_data *cbd = ud;
/* Begin of connection */
if (what == EV_WRITE) {
/* Can write request */
write_http_request (cbd->map, cbd->data, fd);
/* Plan reading */
- event_set (&cbd->ev, cbd->fd, EV_READ | EV_PERSIST, http_async_callback, cbd);
+ event_set (&cbd->ev,
+ cbd->fd,
+ EV_READ | EV_PERSIST,
+ http_async_callback,
+ cbd);
event_base_set (cbd->ev_base, &cbd->ev);
cbd->tv.tv_sec = HTTP_READ_TIMEOUT;
cbd->tv.tv_usec = 0;
cbd->reply = g_malloc (sizeof (struct http_reply));
cbd->reply->parser_state = 0;
cbd->reply->code = 404;
- cbd->reply->headers = g_hash_table_new_full (rspamd_strcase_hash, rspamd_strcase_equal, g_free, g_free);
+ cbd->reply->headers = g_hash_table_new_full (rspamd_strcase_hash,
+ rspamd_strcase_equal,
+ g_free,
+ g_free);
cbd->cbdata.state = 0;
cbd->cbdata.prev_data = *cbd->map->user_data;
cbd->cbdata.cur_data = NULL;
/* Got reply, parse it */
else if (what == EV_READ) {
if (cbd->state >= 1) {
- if (!read_http_common (cbd->map, cbd->data, cbd->reply, &cbd->cbdata, cbd->fd)) {
+ if (!read_http_common (cbd->map, cbd->data, cbd->reply,
+ &cbd->cbdata, cbd->fd)) {
/* Handle Not-Modified in a special way */
if (cbd->reply->code == 304) {
if (cbd->data->last_checked == (time_t)-1) {
cbd->data->last_checked = time (NULL);
}
- msg_info ("data is not modified for server %s", cbd->data->host);
+ msg_info ("data is not modified for server %s",
+ cbd->data->host);
}
else if (cbd->cbdata.cur_data != NULL) {
/* Destroy old data and start reading request data */
static void
http_callback (gint fd, short what, void *ud)
{
- struct rspamd_map *map = ud;
- struct http_map_data *data = map->map_data;
- gint sock;
- struct http_callback_data *cbd;
- gdouble jittered_sec;
+ struct rspamd_map *map = ud;
+ struct http_map_data *data = map->map_data;
+ gint sock;
+ struct http_callback_data *cbd;
+ gdouble jittered_sec;
/* Plan event again with jitter */
evtimer_del (&map->ev);
- jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
+ jittered_sec =
+ (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
if (g_atomic_int_get (map->locked)) {
- msg_info ("don't try to reread map as it is locked by other process, will reread it later");
+ msg_info (
+ "don't try to reread map as it is locked by other process, will reread it later");
return;
}
void
start_map_watch (struct rspamd_config *cfg, struct event_base *ev_base)
{
- GList *cur = cfg->maps;
- struct rspamd_map *map;
- struct file_map_data *fdata;
- gdouble jittered_sec;
+ GList *cur = cfg->maps;
+ struct rspamd_map *map;
+ struct file_map_data *fdata;
+ gdouble jittered_sec;
/* First of all do synced read of data */
while (cur) {
read_map_file (map, map->map_data);
}
/* Plan event with jitter */
- jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout) / 2.;
+ jittered_sec =
+ (map->cfg->map_timeout + g_random_double () *
+ map->cfg->map_timeout) / 2.;
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
}
/* Read initial data */
read_http_sync (map, map->map_data);
/* Plan event with jitter */
- jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
+ jittered_sec =
+ (map->cfg->map_timeout + g_random_double () *
+ map->cfg->map_timeout);
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
}
}
}
-void
+void
remove_all_maps (struct rspamd_config *cfg)
{
g_list_free (cfg->maps);
gboolean
check_map_proto (const gchar *map_line, gint *res, const gchar **pos)
{
- if (g_ascii_strncasecmp (map_line, "http://", sizeof ("http://") - 1) == 0) {
+ if (g_ascii_strncasecmp (map_line, "http://",
+ sizeof ("http://") - 1) == 0) {
if (res && pos) {
*res = MAP_PROTO_HTTP;
*pos = map_line + sizeof ("http://") - 1;
}
}
- else if (g_ascii_strncasecmp (map_line, "file://", sizeof ("file://") - 1) == 0) {
+ else if (g_ascii_strncasecmp (map_line, "file://", sizeof ("file://") -
+ 1) == 0) {
if (res && pos) {
*res = MAP_PROTO_FILE;
*pos = map_line + sizeof ("file://") - 1;
}
gboolean
-add_map (struct rspamd_config *cfg, const gchar *map_line, const gchar *description,
- map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data)
+add_map (struct rspamd_config *cfg,
+ const gchar *map_line,
+ const gchar *description,
+ map_cb_t read_callback,
+ map_fin_cb_t fin_callback,
+ void **user_data)
{
- struct rspamd_map *new_map;
- enum fetch_proto proto;
- const gchar *def, *p, *hostend;
- struct file_map_data *fdata;
- struct http_map_data *hdata;
- gchar portbuf[6];
- gint i, s, r;
- struct addrinfo hints, *res;
+ struct rspamd_map *new_map;
+ enum fetch_proto proto;
+ const gchar *def, *p, *hostend;
+ struct file_map_data *fdata;
+ struct http_map_data *hdata;
+ gchar portbuf[6];
+ gint i, s, r;
+ struct addrinfo hints, *res;
/* First of all detect protocol line */
if (!check_map_proto (map_line, (int *)&proto, &def)) {
new_map->protocol = proto;
new_map->cfg = cfg;
new_map->id = g_random_int ();
- new_map->locked = rspamd_mempool_alloc0_shared (cfg->cfg_pool, sizeof (gint));
+ new_map->locked =
+ rspamd_mempool_alloc0_shared (cfg->cfg_pool, sizeof (gint));
if (proto == MAP_PROTO_FILE) {
new_map->uri = rspamd_mempool_strdup (cfg->cfg_pool, def);
new_map->uri = rspamd_mempool_strdup (cfg->cfg_pool, map_line);
}
if (description != NULL) {
- new_map->description = rspamd_mempool_strdup (cfg->cfg_pool, description);
+ new_map->description =
+ rspamd_mempool_strdup (cfg->cfg_pool, description);
}
/* Now check for each proto separately */
if (proto == MAP_PROTO_FILE) {
- fdata = rspamd_mempool_alloc0 (cfg->map_pool, sizeof (struct file_map_data));
+ fdata =
+ rspamd_mempool_alloc0 (cfg->map_pool,
+ sizeof (struct file_map_data));
if (access (def, R_OK) == -1) {
if (errno != ENOENT) {
msg_err ("cannot open file '%s': %s", def, strerror (errno));
return FALSE;
}
- msg_info ("map '%s' is not found, but it can be loaded automatically later", def);
+ msg_info (
+ "map '%s' is not found, but it can be loaded automatically later",
+ def);
/* We still can add this file */
fdata->st.st_mtime = -1;
}
new_map->map_data = fdata;
}
else if (proto == MAP_PROTO_HTTP) {
- hdata = rspamd_mempool_alloc0 (cfg->map_pool, sizeof (struct http_map_data));
+ hdata =
+ rspamd_mempool_alloc0 (cfg->map_pool,
+ sizeof (struct http_map_data));
/* Try to search port */
if ((p = strchr (def, ':')) != NULL) {
hostend = p;
if ((r = getaddrinfo (hdata->host, portbuf, &hints, &res)) == 0) {
hdata->addr = res;
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)freeaddrinfo, hdata->addr);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)freeaddrinfo, hdata->addr);
}
else {
- msg_err ("address resolution for %s failed: %s", hdata->host, gai_strerror (r));
+ msg_err ("address resolution for %s failed: %s",
+ hdata->host,
+ gai_strerror (r));
return FALSE;
}
/* Now try to connect */
if ((s = make_tcp_socket (hdata->addr, FALSE, FALSE)) == -1) {
- msg_info ("cannot connect to http server %s: %d, %s", hdata->host, errno, strerror (errno));
+ msg_info ("cannot connect to http server %s: %d, %s",
+ hdata->host,
+ errno,
+ strerror (errno));
return FALSE;
}
close (s);
gchar *host;
time_t last_checked;
gshort chunked;
- gchar read_buf[BUFSIZ];
+ gchar read_buf[BUFSIZ];
guint32 rlen;
guint32 chunk;
guint32 chunk_remain;
/**
* Callback types
*/
-typedef gchar* (*map_cb_t)(rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
+typedef gchar * (*map_cb_t)(rspamd_mempool_t *pool, gchar *chunk, gint len,
+ struct map_cb_data *data);
typedef void (*map_fin_cb_t)(rspamd_mempool_t *pool, struct map_cb_data *data);
/**
/**
* Add map from line
*/
-gboolean add_map (struct rspamd_config *cfg, const gchar *map_line, const gchar *description,
- map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data);
+gboolean add_map (struct rspamd_config *cfg,
+ const gchar *map_line,
+ const gchar *description,
+ map_cb_t read_callback,
+ map_fin_cb_t fin_callback,
+ void **user_data);
/**
* Start watching of maps by adding events to libevent event loop
*/
void remove_all_maps (struct rspamd_config *cfg);
-typedef void (*insert_func) (gpointer st, gconstpointer key, gconstpointer value);
+typedef void (*insert_func) (gpointer st, gconstpointer key,
+ gconstpointer value);
/**
* Common callbacks for frequent types of lists
/**
* Radix list is a list like ip/mask
*/
-gchar* read_radix_list (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
+gchar * read_radix_list (rspamd_mempool_t *pool,
+ gchar *chunk,
+ gint len,
+ struct map_cb_data *data);
void fin_radix_list (rspamd_mempool_t *pool, struct map_cb_data *data);
/**
* Host list is an ordinal list of hosts or domains
*/
-gchar* read_host_list (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
+gchar * read_host_list (rspamd_mempool_t *pool,
+ gchar *chunk,
+ gint len,
+ struct map_cb_data *data);
void fin_host_list (rspamd_mempool_t *pool, struct map_cb_data *data);
/**
* Kv list is an ordinal list of keys and values separated by whitespace
*/
-gchar* read_kv_list (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
+gchar * read_kv_list (rspamd_mempool_t *pool,
+ gchar *chunk,
+ gint len,
+ struct map_cb_data *data);
void fin_kv_list (rspamd_mempool_t *pool, struct map_cb_data *data);
/**
* FSM for lists parsing (support comments, blank lines and partial replies)
*/
-gchar * abstract_parse_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data, insert_func func);
+gchar * abstract_parse_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data,
+ insert_func func);
#endif
*/
#include "config.h"
-#include "mem_pool.h"
#include "fstring.h"
#include "logger.h"
-#include "util.h"
#include "main.h"
+#include "mem_pool.h"
+#include "util.h"
/* Sleep time for spin lock in nanoseconds */
#define MUTEX_SLEEP_TIME 10000000L
#define MUTEX_SPIN_COUNT 100
#ifdef _THREAD_SAFE
-pthread_mutex_t stat_mtx = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t stat_mtx = PTHREAD_MUTEX_INITIALIZER;
# define STAT_LOCK() do { pthread_mutex_lock (&stat_mtx); } while (0)
# define STAT_UNLOCK() do { pthread_mutex_unlock (&stat_mtx); } while (0)
#else
# define STAT_UNLOCK() do {} while (0)
#endif
-#define POOL_MTX_LOCK() do { rspamd_mutex_lock (pool->mtx); } while (0)
-#define POOL_MTX_UNLOCK() do { rspamd_mutex_unlock (pool->mtx); } while (0)
+#define POOL_MTX_LOCK() do { rspamd_mutex_lock (pool->mtx); } while (0)
+#define POOL_MTX_UNLOCK() do { rspamd_mutex_unlock (pool->mtx); } while (0)
-/*
+/*
* This define specify whether we should check all pools for free space for new object
* or just begin scan from current (recently attached) pool
* If MEMORY_GREEDY is defined, then we scan all pools to find free space (more CPU usage, slower
#undef MEMORY_GREEDY
/* Internal statistic */
-static rspamd_mempool_stat_t *mem_pool_stat = NULL;
+static rspamd_mempool_stat_t *mem_pool_stat = NULL;
/**
* Function that return free space in pool page
return (gint)chain->len - (chain->pos - chain->begin + MEM_ALIGNMENT);
}
-static struct _pool_chain *
+static struct _pool_chain *
pool_chain_new (gsize size)
{
- struct _pool_chain *chain;
+ struct _pool_chain *chain;
g_return_val_if_fail (size > 0, NULL);
chain = g_slice_alloc (sizeof (struct _pool_chain));
if (chain == NULL) {
- msg_err ("cannot allocate %z bytes, aborting", sizeof (struct _pool_chain));
+ msg_err ("cannot allocate %z bytes, aborting",
+ sizeof (struct _pool_chain));
abort ();
}
static struct _pool_chain_shared *
pool_chain_new_shared (gsize size)
{
- struct _pool_chain_shared *chain;
- gpointer map;
+ struct _pool_chain_shared *chain;
+ gpointer map;
#if defined(HAVE_MMAP_ANON)
- map = mmap (NULL, size + sizeof (struct _pool_chain_shared), PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
+ map = mmap (NULL,
+ size + sizeof (struct _pool_chain_shared),
+ PROT_READ | PROT_WRITE,
+ MAP_ANON | MAP_SHARED,
+ -1,
+ 0);
if (map == MAP_FAILED) {
- msg_err ("cannot allocate %z bytes, aborting", size + sizeof (struct _pool_chain));
+ msg_err ("cannot allocate %z bytes, aborting", size +
+ sizeof (struct _pool_chain));
abort ();
}
chain = (struct _pool_chain_shared *)map;
chain->begin = ((guint8 *) chain) + sizeof (struct _pool_chain_shared);
#elif defined(HAVE_MMAP_ZERO)
- gint fd;
+ gint fd;
fd = open ("/dev/zero", O_RDWR);
if (fd == -1) {
return NULL;
}
- map = mmap (NULL, size + sizeof (struct _pool_chain_shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ map = mmap (NULL,
+ size + sizeof (struct _pool_chain_shared),
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED,
+ fd,
+ 0);
if (map == MAP_FAILED) {
- msg_err ("cannot allocate %z bytes, aborting", size + sizeof (struct _pool_chain));
+ msg_err ("cannot allocate %z bytes, aborting", size +
+ sizeof (struct _pool_chain));
abort ();
}
chain = (struct _pool_chain_shared *)map;
chain->begin = ((guint8 *) chain) + sizeof (struct _pool_chain_shared);
#else
-# error No mmap methods are defined
+# error No mmap methods are defined
#endif
chain->pos = align_ptr (chain->begin, MEM_ALIGNMENT);
chain->len = size;
/**
- * Allocate new memory poll
+ * Allocate new memory poll
* @param size size of pool's page
* @return new memory pool object
*/
-rspamd_mempool_t *
+rspamd_mempool_t *
rspamd_mempool_new (gsize size)
{
- rspamd_mempool_t *new;
- gpointer map;
+ rspamd_mempool_t *new;
+ gpointer map;
g_return_val_if_fail (size > 0, NULL);
/* Allocate statistic structure if it is not allocated before */
if (mem_pool_stat == NULL) {
#if defined(HAVE_MMAP_ANON)
- map = mmap (NULL, sizeof (rspamd_mempool_stat_t), PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
+ map = mmap (NULL,
+ sizeof (rspamd_mempool_stat_t),
+ PROT_READ | PROT_WRITE,
+ MAP_ANON | MAP_SHARED,
+ -1,
+ 0);
if (map == MAP_FAILED) {
- msg_err ("cannot allocate %z bytes, aborting", sizeof (rspamd_mempool_stat_t));
+ msg_err ("cannot allocate %z bytes, aborting",
+ sizeof (rspamd_mempool_stat_t));
abort ();
}
mem_pool_stat = (rspamd_mempool_stat_t *)map;
#elif defined(HAVE_MMAP_ZERO)
- gint fd;
+ gint fd;
fd = open ("/dev/zero", O_RDWR);
g_assert (fd != -1);
- map = mmap (NULL, sizeof (rspamd_mempool_stat_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ map = mmap (NULL,
+ sizeof (rspamd_mempool_stat_t),
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED,
+ fd,
+ 0);
if (map == MAP_FAILED) {
- msg_err ("cannot allocate %z bytes, aborting", sizeof (rspamd_mempool_stat_t));
+ msg_err ("cannot allocate %z bytes, aborting",
+ sizeof (rspamd_mempool_stat_t));
abort ();
}
mem_pool_stat = (rspamd_mempool_stat_t *)map;
#else
-# error No mmap methods are defined
+# error No mmap methods are defined
#endif
memset (map, 0, sizeof (rspamd_mempool_stat_t));
}
new = g_slice_alloc (sizeof (rspamd_mempool_t));
if (new == NULL) {
- msg_err ("cannot allocate %z bytes, aborting", sizeof (rspamd_mempool_t));
+ msg_err ("cannot allocate %z bytes, aborting",
+ sizeof (rspamd_mempool_t));
abort ();
}
return new;
}
-static void *
+static void *
memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size, gboolean is_tmp)
{
- guint8 *tmp;
- struct _pool_chain *new, *cur;
- gint free;
+ guint8 *tmp;
+ struct _pool_chain *new, *cur;
+ gint free;
if (pool) {
POOL_MTX_LOCK ();
#endif
/* Find free space in pool chain */
while (cur != NULL &&
- (free = pool_chain_free (cur)) < (gint)size &&
- cur->next != NULL) {
+ (free = pool_chain_free (cur)) < (gint)size &&
+ cur->next != NULL) {
cur = cur->next;
}
new = pool_chain_new (pool->first_pool->len);
}
else {
- new = pool_chain_new (size + pool->first_pool->len + MEM_ALIGNMENT);
+ new = pool_chain_new (
+ size + pool->first_pool->len + MEM_ALIGNMENT);
}
/* Connect to pool subsystem */
if (is_tmp) {
}
else {
mem_pool_stat->oversized_chunks++;
- new = pool_chain_new (size + pool->first_pool->len + MEM_ALIGNMENT);
+ new = pool_chain_new (
+ size + pool->first_pool->len + MEM_ALIGNMENT);
}
/* Attach new pool to chain */
cur->next = new;
}
-void *
+void *
rspamd_mempool_alloc (rspamd_mempool_t * pool, gsize size)
{
return memory_pool_alloc_common (pool, size, FALSE);
}
-void *
+void *
rspamd_mempool_alloc_tmp (rspamd_mempool_t * pool, gsize size)
{
return memory_pool_alloc_common (pool, size, TRUE);
}
-void *
+void *
rspamd_mempool_alloc0 (rspamd_mempool_t * pool, gsize size)
{
- void *pointer = rspamd_mempool_alloc (pool, size);
+ void *pointer = rspamd_mempool_alloc (pool, size);
if (pointer) {
memset (pointer, 0, size);
}
return pointer;
}
-void *
+void *
rspamd_mempool_alloc0_tmp (rspamd_mempool_t * pool, gsize size)
{
- void *pointer = rspamd_mempool_alloc_tmp (pool, size);
+ void *pointer = rspamd_mempool_alloc_tmp (pool, size);
if (pointer) {
memset (pointer, 0, size);
}
return pointer;
}
-void *
+void *
rspamd_mempool_alloc0_shared (rspamd_mempool_t * pool, gsize size)
{
- void *pointer = rspamd_mempool_alloc_shared (pool, size);
+ void *pointer = rspamd_mempool_alloc_shared (pool, size);
if (pointer) {
memset (pointer, 0, size);
}
gint free;
if (pool) {
- g_return_val_if_fail(size > 0, NULL);
+ g_return_val_if_fail (size > 0, NULL);
POOL_MTX_LOCK ()
;
/* Find free space in pool chain */
while ((free = pool_chain_free ((struct _pool_chain *) cur))
- < (gint) size && cur->next) {
+ < (gint) size && cur->next) {
cur = cur->next;
}
if (free < (gint) size && cur->next == NULL) {
else {
mem_pool_stat->oversized_chunks++;
new = pool_chain_new_shared (
- size + pool->first_pool->len + MEM_ALIGNMENT);
+ size + pool->first_pool->len + MEM_ALIGNMENT);
}
/* Attach new pool to chain */
cur->next = new;
;
return new->begin;
}
- tmp = align_ptr(cur->pos, MEM_ALIGNMENT);
+ tmp = align_ptr (cur->pos, MEM_ALIGNMENT);
cur->pos = tmp + size;
POOL_MTX_UNLOCK ()
;
}
-gchar *
+gchar *
rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src)
{
- gsize len;
- gchar *newstr;
+ gsize len;
+ gchar *newstr;
if (src == NULL) {
return NULL;
return newstr;
}
-gchar *
+gchar *
rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
{
- gchar *newstr;
+ gchar *newstr;
if (src == NULL) {
return NULL;
}
-gchar *
+gchar *
rspamd_mempool_strdup_shared (rspamd_mempool_t * pool, const gchar *src)
{
- gsize len;
- gchar *newstr;
+ gsize len;
+ gchar *newstr;
if (src == NULL) {
return NULL;
static struct _pool_chain_shared *
memory_pool_find_pool (rspamd_mempool_t * pool, void *pointer)
{
- struct _pool_chain_shared *cur = pool->shared_pool;
+ struct _pool_chain_shared *cur = pool->shared_pool;
while (cur) {
- if ((guint8 *) pointer >= cur->begin && (guint8 *) pointer <= (cur->begin + cur->len)) {
+ if ((guint8 *) pointer >= cur->begin && (guint8 *) pointer <=
+ (cur->begin + cur->len)) {
return cur;
}
cur = cur->next;
g_atomic_int_set (&mutex->spin, MUTEX_SPIN_COUNT);
}
#ifdef HAVE_ASM_PAUSE
- __asm __volatile ("pause");
+ __asm __volatile ("pause");
#elif defined(HAVE_SCHED_YIELD)
(void)sched_yield ();
#endif
#if defined(HAVE_NANOSLEEP)
- struct timespec ts;
+ struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = MUTEX_SLEEP_TIME;
/* Spin */
- while (nanosleep (&ts, &ts) == -1 && errno == EINTR);
+ while (nanosleep (&ts, &ts) == -1 && errno == EINTR) ;
#else
-# error No methods to spin are defined
+# error No methods to spin are defined
#endif
return 1;
}
void
rspamd_mempool_lock_shared (rspamd_mempool_t * pool, void *pointer)
{
- struct _pool_chain_shared *chain;
+ struct _pool_chain_shared *chain;
chain = memory_pool_find_pool (pool, pointer);
if (chain == NULL) {
void
rspamd_mempool_unlock_shared (rspamd_mempool_t * pool, void *pointer)
{
- struct _pool_chain_shared *chain;
+ struct _pool_chain_shared *chain;
chain = memory_pool_find_pool (pool, pointer);
if (chain == NULL) {
}
void
-rspamd_mempool_add_destructor_full (rspamd_mempool_t * pool, rspamd_mempool_destruct_t func, void *data,
- const gchar *function, const gchar *line)
+rspamd_mempool_add_destructor_full (rspamd_mempool_t * pool,
+ rspamd_mempool_destruct_t func,
+ void *data,
+ const gchar *function,
+ const gchar *line)
{
- struct _pool_destructors *cur;
+ struct _pool_destructors *cur;
cur = rspamd_mempool_alloc (pool, sizeof (struct _pool_destructors));
if (cur) {
}
void
-rspamd_mempool_replace_destructor (rspamd_mempool_t * pool, rspamd_mempool_destruct_t func, void *old_data, void *new_data)
+rspamd_mempool_replace_destructor (rspamd_mempool_t * pool,
+ rspamd_mempool_destruct_t func,
+ void *old_data,
+ void *new_data)
{
- struct _pool_destructors *tmp;
+ struct _pool_destructors *tmp;
tmp = pool->destructors;
while (tmp) {
void
rspamd_mempool_delete (rspamd_mempool_t * pool)
{
- struct _pool_chain *cur = pool->first_pool, *tmp;
- struct _pool_chain_shared *cur_shared = pool->shared_pool, *tmp_shared;
- struct _pool_destructors *destructor = pool->destructors;
+ struct _pool_chain *cur = pool->first_pool, *tmp;
+ struct _pool_chain_shared *cur_shared = pool->shared_pool, *tmp_shared;
+ struct _pool_destructors *destructor = pool->destructors;
POOL_MTX_LOCK ();
/* Call all pool destructors */
mem_pool_stat->chunks_freed++;
mem_pool_stat->bytes_allocated -= tmp_shared->len;
STAT_UNLOCK ();
- munmap ((void *)tmp_shared, tmp_shared->len + sizeof (struct _pool_chain_shared));
+ munmap ((void *)tmp_shared, tmp_shared->len +
+ sizeof (struct _pool_chain_shared));
}
if (pool->variables) {
g_hash_table_destroy (pool->variables);
}
void
-rspamd_mempool_cleanup_tmp (rspamd_mempool_t* pool)
+rspamd_mempool_cleanup_tmp (rspamd_mempool_t * pool)
{
- struct _pool_chain *cur = pool->first_pool, *tmp;
+ struct _pool_chain *cur = pool->first_pool, *tmp;
POOL_MTX_LOCK ();
cur = pool->first_pool_tmp;
#endif
}
-rspamd_mempool_mutex_t *
+rspamd_mempool_mutex_t *
rspamd_mempool_get_mutex (rspamd_mempool_t * pool)
{
- rspamd_mempool_mutex_t *res;
+ rspamd_mempool_mutex_t *res;
if (pool != NULL) {
- res = rspamd_mempool_alloc_shared (pool, sizeof (rspamd_mempool_mutex_t));
+ res =
+ rspamd_mempool_alloc_shared (pool, sizeof (rspamd_mempool_mutex_t));
res->lock = 0;
res->owner = 0;
res->spin = MUTEX_SPIN_COUNT;
(void)g_atomic_int_compare_and_exchange (&mutex->lock, 1, 0);
}
-rspamd_mempool_rwlock_t *
+rspamd_mempool_rwlock_t *
rspamd_mempool_get_rwlock (rspamd_mempool_t * pool)
{
- rspamd_mempool_rwlock_t *lock;
+ rspamd_mempool_rwlock_t *lock;
lock = rspamd_mempool_alloc_shared (pool, sizeof (rspamd_mempool_rwlock_t));
lock->__r_lock = rspamd_mempool_get_mutex (pool);
rspamd_mempool_unlock_mutex (lock->__w_lock);
}
-void
-rspamd_mempool_set_variable (rspamd_mempool_t *pool, const gchar *name, gpointer value, rspamd_mempool_destruct_t destructor)
+void
+rspamd_mempool_set_variable (rspamd_mempool_t *pool,
+ const gchar *name,
+ gpointer value,
+ rspamd_mempool_destruct_t destructor)
{
if (pool->variables == NULL) {
pool->variables = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
}
- g_hash_table_insert (pool->variables, rspamd_mempool_strdup (pool, name), value);
+ g_hash_table_insert (pool->variables, rspamd_mempool_strdup (pool,
+ name), value);
if (destructor != NULL) {
rspamd_mempool_add_destructor (pool, destructor, value);
}
#define MEM_ALIGNMENT sizeof(unsigned long) /* platform word */
#define align_ptr(p, a) \
- (guint8 *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
+ (guint8 *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
-/**
- * Destructor type definition
+/**
+ * Destructor type definition
*/
typedef void (*rspamd_mempool_destruct_t)(void *ptr);
* Pool page structure
*/
struct _pool_chain {
- guint8 *begin; /**< begin of pool chain block */
- guint8 *pos; /**< current start of free space in block */
- gsize len; /**< length of block */
- struct _pool_chain *next; /**< chain link */
+ guint8 *begin; /**< begin of pool chain block */
+ guint8 *pos; /**< current start of free space in block */
+ gsize len; /**< length of block */
+ struct _pool_chain *next; /**< chain link */
};
/**
* Destructors list item structure
*/
struct _pool_destructors {
- rspamd_mempool_destruct_t func; /**< pointer to destructor */
- void *data; /**< data to free */
- const gchar *function; /**< function from which this destructor was added */
- const gchar *loc; /**< line number */
- struct _pool_destructors *prev; /**< chain link */
+ rspamd_mempool_destruct_t func; /**< pointer to destructor */
+ void *data; /**< data to free */
+ const gchar *function; /**< function from which this destructor was added */
+ const gchar *loc; /**< line number */
+ struct _pool_destructors *prev; /**< chain link */
};
/**
*/
struct rspamd_mutex_s;
typedef struct memory_pool_s {
- struct _pool_chain *cur_pool; /**< currently used page */
- struct _pool_chain *first_pool; /**< first page */
- struct _pool_chain *cur_pool_tmp; /**< currently used temporary page */
- struct _pool_chain *first_pool_tmp; /**< first temporary page */
- struct _pool_chain_shared *shared_pool; /**< shared chain */
- struct _pool_destructors *destructors; /**< destructors chain */
- GHashTable *variables; /**< private memory pool variables */
- struct rspamd_mutex_s *mtx; /**< threads lock */
+ struct _pool_chain *cur_pool; /**< currently used page */
+ struct _pool_chain *first_pool; /**< first page */
+ struct _pool_chain *cur_pool_tmp; /**< currently used temporary page */
+ struct _pool_chain *first_pool_tmp; /**< first temporary page */
+ struct _pool_chain_shared *shared_pool; /**< shared chain */
+ struct _pool_destructors *destructors; /**< destructors chain */
+ GHashTable *variables; /**< private memory pool variables */
+ struct rspamd_mutex_s *mtx; /**< threads lock */
} rspamd_mempool_t;
/**
* Statistics structure
*/
typedef struct memory_pool_stat_s {
- gsize pools_allocated; /**< total number of allocated pools */
- gsize pools_freed; /**< number of freed pools */
- gsize bytes_allocated; /**< bytes that are allocated with pool allocator */
- gsize chunks_allocated; /**< number of chunks that are allocated */
- gsize shared_chunks_allocated; /**< shared chunks allocated */
- gsize chunks_freed; /**< chunks freed */
- gsize oversized_chunks; /**< oversized chunks */
+ gsize pools_allocated; /**< total number of allocated pools */
+ gsize pools_freed; /**< number of freed pools */
+ gsize bytes_allocated; /**< bytes that are allocated with pool allocator */
+ gsize chunks_allocated; /**< number of chunks that are allocated */
+ gsize shared_chunks_allocated; /**< shared chunks allocated */
+ gsize chunks_freed; /**< chunks freed */
+ gsize oversized_chunks; /**< oversized chunks */
} rspamd_mempool_stat_t;
/**
* Rwlock for locking shared memory regions
*/
typedef struct memory_pool_rwlock_s {
- rspamd_mempool_mutex_t *__r_lock; /**< read mutex (private) */
- rspamd_mempool_mutex_t *__w_lock; /**< write mutex (private) */
+ rspamd_mempool_mutex_t *__r_lock; /**< read mutex (private) */
+ rspamd_mempool_mutex_t *__w_lock; /**< write mutex (private) */
} rspamd_mempool_rwlock_t;
/**
- * Allocate new memory poll
+ * Allocate new memory poll
* @param size size of pool's page
* @return new memory pool object
*/
-rspamd_mempool_t* rspamd_mempool_new (gsize size);
+rspamd_mempool_t * rspamd_mempool_new (gsize size);
-/**
+/**
* Get memory from pool
* @param pool memory pool object
* @param size bytes to allocate
* @return pointer to allocated object
*/
-void* rspamd_mempool_alloc (rspamd_mempool_t* pool, gsize size);
+void * rspamd_mempool_alloc (rspamd_mempool_t * pool, gsize size);
/**
* Get memory from temporary pool
* @param size bytes to allocate
* @return pointer to allocated object
*/
-void* rspamd_mempool_alloc_tmp (rspamd_mempool_t* pool, gsize size);
+void * rspamd_mempool_alloc_tmp (rspamd_mempool_t * pool, gsize size);
/**
* Get memory and set it to zero
* @param size bytes to allocate
* @return pointer to allocated object
*/
-void* rspamd_mempool_alloc0 (rspamd_mempool_t* pool, gsize size);
+void * rspamd_mempool_alloc0 (rspamd_mempool_t * pool, gsize size);
/**
* Get memory and set it to zero
* @param size bytes to allocate
* @return pointer to allocated object
*/
-void* rspamd_mempool_alloc0_tmp (rspamd_mempool_t* pool, gsize size);
+void * rspamd_mempool_alloc0_tmp (rspamd_mempool_t * pool, gsize size);
/**
* Cleanup temporary data in pool
*/
-void rspamd_mempool_cleanup_tmp (rspamd_mempool_t* pool);
+void rspamd_mempool_cleanup_tmp (rspamd_mempool_t * pool);
/**
* Make a copy of string in pool
* @param src source string
* @return pointer to newly created string that is copy of src
*/
-gchar* rspamd_mempool_strdup (rspamd_mempool_t* pool, const gchar *src);
+gchar * rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src);
/**
* Make a copy of fixed string in pool as null terminated string
* @param src source string
* @return pointer to newly created string that is copy of src
*/
-gchar* rspamd_mempool_fstrdup (rspamd_mempool_t* pool, const struct f_str_s *src);
+gchar * rspamd_mempool_fstrdup (rspamd_mempool_t * pool,
+ const struct f_str_s *src);
/**
* Allocate piece of shared memory
* @param pool memory pool object
* @param size bytes to allocate
*/
-void* rspamd_mempool_alloc_shared (rspamd_mempool_t* pool, gsize size);
-void* rspamd_mempool_alloc0_shared (rspamd_mempool_t *pool, gsize size);
-gchar* rspamd_mempool_strdup_shared (rspamd_mempool_t* pool, const gchar *src);
+void * rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size);
+void * rspamd_mempool_alloc0_shared (rspamd_mempool_t *pool, gsize size);
+gchar * rspamd_mempool_strdup_shared (rspamd_mempool_t * pool,
+ const gchar *src);
/**
* Lock chunk of shared memory in which pointer is placed
* @param func pointer to function-destructor
* @param data pointer to data that would be passed to destructor
*/
-void rspamd_mempool_add_destructor_full (rspamd_mempool_t *pool, rspamd_mempool_destruct_t func, void *data,
- const gchar *function, const gchar *line);
+void rspamd_mempool_add_destructor_full (rspamd_mempool_t *pool,
+ rspamd_mempool_destruct_t func,
+ void *data,
+ const gchar *function,
+ const gchar *line);
/* Macros for common usage */
#define rspamd_mempool_add_destructor(pool, func, data) \
- rspamd_mempool_add_destructor_full(pool, func, data, G_STRFUNC, G_STRLOC)
+ rspamd_mempool_add_destructor_full (pool, func, data, G_STRFUNC, G_STRLOC)
/**
* Replace destructor callback to pool for specified pointer
* @param new_data pointer to data that would be passed to destructor
*/
void rspamd_mempool_replace_destructor (rspamd_mempool_t *pool,
- rspamd_mempool_destruct_t func, void *old_data, void *new_data);
+ rspamd_mempool_destruct_t func, void *old_data, void *new_data);
/**
* Delete pool, free all its chunks and call destructors chain
*/
void rspamd_mempool_delete (rspamd_mempool_t *pool);
-/**
+/**
* Get new mutex from pool (allocated in shared memory)
* @param pool memory pool object
* @return mutex object
*/
-rspamd_mempool_mutex_t* rspamd_mempool_get_mutex (rspamd_mempool_t *pool);
+rspamd_mempool_mutex_t * rspamd_mempool_get_mutex (rspamd_mempool_t *pool);
/**
* Lock mutex
* @param pool memory pool object
* @return rwlock object
*/
-rspamd_mempool_rwlock_t* rspamd_mempool_get_rwlock (rspamd_mempool_t *pool);
+rspamd_mempool_rwlock_t * rspamd_mempool_get_rwlock (rspamd_mempool_t *pool);
/**
* Aquire read lock
* @param destructor pointer to function-destructor
*/
void rspamd_mempool_set_variable (rspamd_mempool_t *pool, const gchar *name,
- gpointer value, rspamd_mempool_destruct_t destructor);
+ gpointer value, rspamd_mempool_destruct_t destructor);
/**
* Get memory pool variable
* @param name name of variable
* @return NULL or pointer to variable data
*/
-gpointer rspamd_mempool_get_variable (rspamd_mempool_t *pool, const gchar *name);
+gpointer rspamd_mempool_get_variable (rspamd_mempool_t *pool,
+ const gchar *name);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "printf.h"
#include "fstring.h"
#include "main.h"
+#include "printf.h"
/**
* From FreeBSD libutil code
static gchar *
rspamd_sprintf_num (gchar *buf, gchar *last, guint64 ui64, gchar zero,
- guint hexadecimal, guint width)
+ guint hexadecimal, guint width)
{
- gchar *p, temp[sizeof ("18446744073709551615")];
- size_t len;
- guint32 ui32;
- static gchar hex[] = "0123456789abcdef";
- static gchar HEX[] = "0123456789ABCDEF";
+ gchar *p, temp[sizeof ("18446744073709551615")];
+ size_t len;
+ guint32 ui32;
+ static gchar hex[] = "0123456789abcdef";
+ static gchar HEX[] = "0123456789ABCDEF";
p = temp + sizeof(temp);
glong
rspamd_fprintf (FILE *f, const gchar *fmt, ...)
{
- va_list args;
+ va_list args;
glong r;
va_start (args, fmt);
glong
rspamd_printf (const gchar *fmt, ...)
{
- va_list args;
+ va_list args;
glong r;
va_start (args, fmt);
glong
rspamd_log_fprintf (FILE *f, const gchar *fmt, ...)
{
- va_list args;
+ va_list args;
glong r;
va_start (args, fmt);
return r;
}
-#define RSPAMD_PRINTF_APPEND(buf, len) \
- do { \
- wr = func ((buf), (len), apd); \
- if (wr < (__typeof(wr))(len)) { \
- goto oob; \
- } \
- written += wr; \
- fmt ++; \
- buf_start = fmt; \
- } while(0)
+#define RSPAMD_PRINTF_APPEND(buf, len) \
+ do { \
+ wr = func ((buf), (len), apd); \
+ if (wr < (__typeof (wr))(len)) { \
+ goto oob; \
+ } \
+ written += wr; \
+ fmt++; \
+ buf_start = fmt; \
+ } while (0)
glong
-rspamd_vprintf_common (rspamd_printf_append_func func, gpointer apd, const gchar *fmt, va_list args)
+rspamd_vprintf_common (rspamd_printf_append_func func,
+ gpointer apd,
+ const gchar *fmt,
+ va_list args)
{
- gchar zero, numbuf[G_ASCII_DTOSTR_BUF_SIZE], *p, *last, c;
- const gchar *buf_start = fmt;
- gint d;
- long double f, scale;
- glong written = 0, wr, slen;
- gint64 i64;
- guint64 ui64;
- guint width, sign, hex, humanize, bytes, frac_width, i;
- f_str_t *v;
- GString *gs;
- gboolean bv;
+ gchar zero, numbuf[G_ASCII_DTOSTR_BUF_SIZE], *p, *last, c;
+ const gchar *buf_start = fmt;
+ gint d;
+ long double f, scale;
+ glong written = 0, wr, slen;
+ gint64 i64;
+ guint64 ui64;
+ guint width, sign, hex, humanize, bytes, frac_width, i;
+ f_str_t *v;
+ GString *gs;
+ gboolean bv;
while (*fmt) {
}
- for ( ;; ) {
+ for (;; ) {
switch (*fmt) {
case 'u':
humanize = 1;
bytes = 1;
sign = 0;
- fmt ++;
+ fmt++;
continue;
case 'h':
humanize = 1;
sign = 0;
- fmt ++;
+ fmt++;
continue;
case '.':
fmt++;
case 'l':
if (sign) {
- i64 = (gint64) va_arg(args, glong);
+ i64 = (gint64) va_arg (args, glong);
} else {
- ui64 = (guint64) va_arg(args, gulong);
+ ui64 = (guint64) va_arg (args, gulong);
}
break;
case 'D':
if (sign) {
- i64 = (gint64) va_arg(args, gint32);
+ i64 = (gint64) va_arg (args, gint32);
} else {
- ui64 = (guint64) va_arg(args, guint32);
+ ui64 = (guint64) va_arg (args, guint32);
}
break;
}
/*
- * (gint64) cast is required for msvc6:
- * it can not convert guint64 to double
- */
+ * (gint64) cast is required for msvc6:
+ * it can not convert guint64 to double
+ */
ui64 = (guint64) ((f - (gint64) ui64) * scale);
p = rspamd_sprintf_num (p, last, ui64, '0', 0, frac_width);
if (sign) {
if (i64 < 0) {
*p++ = '-';
- ui64 = (guint64) -i64;
+ ui64 = (guint64) - i64;
} else {
ui64 = (guint64) i64;
* @param ud opaque pointer
* @return number of characters written
*/
-typedef glong (*rspamd_printf_append_func)(const gchar *buf, glong buflen, gpointer ud);
+typedef glong (*rspamd_printf_append_func)(const gchar *buf, glong buflen,
+ gpointer ud);
glong rspamd_fprintf (FILE *f, const gchar *fmt, ...);
glong rspamd_printf (const gchar *fmt, ...);
glong rspamd_log_fprintf (FILE *f, const gchar *fmt, ...);
glong rspamd_snprintf (gchar *buf, glong max, const gchar *fmt, ...);
-gchar *rspamd_vsnprintf (gchar *buf, glong max, const gchar *fmt, va_list args);
+gchar * rspamd_vsnprintf (gchar *buf, glong max, const gchar *fmt,
+ va_list args);
glong rspamd_printf_gstring (GString *s, const gchar *fmt, ...);
-glong rspamd_vprintf_common (rspamd_printf_append_func func, gpointer apd, const gchar *fmt, va_list args);
+glong rspamd_vprintf_common (rspamd_printf_append_func func,
+ gpointer apd,
+ const gchar *fmt,
+ va_list args);
#endif /* PRINTF_H_ */
#include "config.h"
-#include "radix.h"
#include "mem_pool.h"
+#include "radix.h"
-static void *radix_alloc (radix_tree_t * tree);
+static void * radix_alloc (radix_tree_t * tree);
-radix_tree_t *
+radix_tree_t *
radix_tree_create (void)
{
- radix_tree_t *tree;
+ radix_tree_t *tree;
tree = g_malloc (sizeof (radix_tree_t));
if (tree == NULL) {
};
static uintptr_t
-radix32tree_insert_common (radix_tree_t * tree, guint32 key, guint32 mask, uintptr_t value, enum radix_insert_type type)
+radix32tree_insert_common (radix_tree_t * tree,
+ guint32 key,
+ guint32 mask,
+ uintptr_t value,
+ enum radix_insert_type type)
{
- guint32 bit;
- radix_node_t *node, *next;
+ guint32 bit;
+ radix_node_t *node, *next;
bit = 0x80000000;
if (node->value != RADIX_NO_VALUE) {
/* Value was found, switch on insert type */
switch (type) {
- case RADIX_INSERT:
- return 1;
- case RADIX_ADD:
- node->value += value;
- return value;
- case RADIX_REPLACE:
- node->value = value;
- return 1;
+ case RADIX_INSERT:
+ return 1;
+ case RADIX_ADD:
+ node->value += value;
+ return value;
+ case RADIX_REPLACE:
+ node->value = value;
+ return 1;
}
}
return 0;
}
-gint
-radix32tree_insert (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
+gint
+radix32tree_insert (radix_tree_t *tree,
+ guint32 key,
+ guint32 mask,
+ uintptr_t value)
{
- return (gint)radix32tree_insert_common (tree, key, mask, value, RADIX_INSERT);
+ return (gint)radix32tree_insert_common (tree, key, mask, value,
+ RADIX_INSERT);
}
-uintptr_t
+uintptr_t
radix32tree_add (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
{
return radix32tree_insert_common (tree, key, mask, value, RADIX_ADD);
}
-gint
-radix32tree_replace (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
+gint
+radix32tree_replace (radix_tree_t *tree,
+ guint32 key,
+ guint32 mask,
+ uintptr_t value)
{
- return (gint)radix32tree_insert_common (tree, key, mask, value, RADIX_REPLACE);
+ return (gint)radix32tree_insert_common (tree,
+ key,
+ mask,
+ value,
+ RADIX_REPLACE);
}
/*
* 5 words total in stack
*/
static gboolean
-radix_recurse_nodes (radix_node_t *node, radix_tree_traverse_func func, void *user_data, gint level)
+radix_recurse_nodes (radix_node_t *node,
+ radix_tree_traverse_func func,
+ void *user_data,
+ gint level)
{
if (node->left) {
if (radix_recurse_nodes (node->left, func, user_data, level + 1)) {
return TRUE;
}
}
-
+
if (node->value != RADIX_NO_VALUE) {
if (func (node->key, level, node->value, user_data)) {
return TRUE;
}
void
-radix32tree_traverse (radix_tree_t *tree, radix_tree_traverse_func func, void *user_data)
+radix32tree_traverse (radix_tree_t *tree,
+ radix_tree_traverse_func func,
+ void *user_data)
{
- radix_recurse_nodes (tree->root, func, user_data, 0);
+ radix_recurse_nodes (tree->root, func, user_data, 0);
}
gint
radix32tree_delete (radix_tree_t * tree, guint32 key, guint32 mask)
{
- guint32 bit;
- radix_node_t *node;
+ guint32 bit;
+ radix_node_t *node;
bit = 0x80000000;
node = tree->root;
return -1;
}
- for (;;) {
+ for (;; ) {
if (node->parent->right == node) {
node->parent->right = NULL;
uintptr_t
radix32tree_find (radix_tree_t * tree, guint32 key)
{
- guint32 bit;
- uintptr_t value;
- radix_node_t *node;
+ guint32 bit;
+ uintptr_t value;
+ radix_node_t *node;
bit = 0x80000000;
value = RADIX_NO_VALUE;
}
-static void *
+static void *
radix_alloc (radix_tree_t * tree)
{
- gchar *p;
+ gchar *p;
p = rspamd_mempool_alloc (tree->pool, sizeof (radix_node_t));
return radix32tree_find (tree, ntohl (addr->addr.s4.sin_addr.s_addr));
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
#define RADIX_NO_VALUE (uintptr_t)-1
-typedef struct radix_node_s radix_node_t;
+typedef struct radix_node_s radix_node_t;
struct radix_node_s {
- radix_node_t *right;
- radix_node_t *left;
- radix_node_t *parent;
- uintptr_t value;
+ radix_node_t *right;
+ radix_node_t *left;
+ radix_node_t *parent;
+ uintptr_t value;
guint32 key;
};
typedef struct {
- radix_node_t *root;
- size_t size;
+ radix_node_t *root;
+ size_t size;
rspamd_mempool_t *pool;
} radix_tree_t;
-typedef gboolean (*radix_tree_traverse_func)(guint32 key, guint32 mask, uintptr_t value, void *user_data);
+typedef gboolean (*radix_tree_traverse_func)(guint32 key, guint32 mask,
+ uintptr_t value, void *user_data);
/**
* Create new radix tree
*/
-radix_tree_t *radix_tree_create (void);
+radix_tree_t * radix_tree_create (void);
/**
* Insert value to radix tree
* 0 if operation was successfull
* -1 if there was some error
*/
-gint radix32tree_insert (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
+gint radix32tree_insert (radix_tree_t *tree,
+ guint32 key,
+ guint32 mask,
+ uintptr_t value);
/**
* Add value to radix tree or insert it if value does not exists
* 0 if value was inserted
* -1 if there was some error
*/
-uintptr_t radix32tree_add (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
+uintptr_t radix32tree_add (radix_tree_t *tree,
+ guint32 key,
+ guint32 mask,
+ uintptr_t value);
/**
* Replace value in radix tree or insert it if value does not exists
* 0 if value was inserted
* -1 if there was some error
*/
-gint radix32tree_replace (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
+gint radix32tree_replace (radix_tree_t *tree,
+ guint32 key,
+ guint32 mask,
+ uintptr_t value);
/**
* Delete value from radix tree
/**
* Traverse via the whole tree calling specified callback
*/
-void radix32tree_traverse (radix_tree_t *tree, radix_tree_traverse_func func, void *user_data);
+void radix32tree_traverse (radix_tree_t *tree,
+ radix_tree_traverse_func func,
+ void *user_data);
/**
* Frees radix tree
/**
* Convert numeric presentation of dst to string
*/
-const gchar*
+const gchar *
rrd_dst_to_string (enum rrd_dst_type type)
{
switch (type) {
/**
* Convert numeric presentation of cf to string
*/
-const gchar*
+const gchar *
rrd_cf_to_string (enum rrd_cf_type type)
{
switch (type) {
}
void
-rrd_make_default_rra (const gchar *cf_name, gulong pdp_cnt, gulong rows, struct rrd_rra_def *rra)
+rrd_make_default_rra (const gchar *cf_name,
+ gulong pdp_cnt,
+ gulong rows,
+ struct rrd_rra_def *rra)
{
rra->pdp_cnt = pdp_cnt;
rra->row_cnt = rows;
void
rrd_make_default_ds (const gchar *name, gulong pdp_step, struct rrd_ds_def *ds)
{
- rspamd_strlcpy (ds->ds_nam, name, sizeof (ds->ds_nam));
- rspamd_strlcpy (ds->dst, "COUNTER", sizeof (ds->dst));
+ rspamd_strlcpy (ds->ds_nam, name, sizeof (ds->ds_nam));
+ rspamd_strlcpy (ds->dst, "COUNTER", sizeof (ds->dst));
memset (ds->par, 0, sizeof (ds->par));
ds->par[RRD_DS_mrhb_cnt].lv = pdp_step * 2;
ds->par[RRD_DS_min_val].dv = NAN;
static gboolean
rspamd_rrd_check_file (const gchar *filename, gboolean need_data, GError **err)
{
- gint fd, i;
- struct stat st;
- struct rrd_file_head head;
- struct rrd_rra_def rra;
- gint head_size;
+ gint fd, i;
+ struct stat st;
+ struct rrd_file_head head;
+ struct rrd_rra_def rra;
+ gint head_size;
fd = open (filename, O_RDWR);
if (fd == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
return FALSE;
}
if (fstat (fd, &st) == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
close (fd);
return FALSE;
}
if (st.st_size < (goffset)sizeof (struct rrd_file_head)) {
/* We have trimmed file */
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd size is bad: %ud", (guint)st.st_size);
+ g_set_error (err, rrd_error_quark (), EINVAL, "rrd size is bad: %ud",
+ (guint)st.st_size);
close (fd);
return FALSE;
}
/* Try to read header */
if (read (fd, &head, sizeof (head)) != sizeof (head)) {
- g_set_error (err, rrd_error_quark (), errno, "rrd read head error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd read head error: %s",
+ strerror (errno));
close (fd);
return FALSE;
}
/* Check magic */
if (memcmp (head.cookie, RRD_COOKIE, sizeof (head.cookie)) != 0 ||
- memcmp (head.version, RRD_VERSION, sizeof (head.version)) != 0 ||
- head.float_cookie != RRD_FLOAT_COOKIE) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd head cookies error: %s", strerror (errno));
+ memcmp (head.version, RRD_VERSION, sizeof (head.version)) != 0 ||
+ head.float_cookie != RRD_FLOAT_COOKIE) {
+ g_set_error (err,
+ rrd_error_quark (), EINVAL, "rrd head cookies error: %s",
+ strerror (errno));
close (fd);
return FALSE;
}
/* Check for other params */
if (head.ds_cnt <= 0 || head.rra_cnt <= 0) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd head cookies error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), EINVAL, "rrd head cookies error: %s",
+ strerror (errno));
close (fd);
return FALSE;
}
/* Now we can calculate the overall size of rrd */
head_size = sizeof (struct rrd_file_head) +
- sizeof (struct rrd_ds_def) * head.ds_cnt +
- sizeof (struct rrd_rra_def) * head.rra_cnt +
- sizeof (struct rrd_live_head) +
- sizeof (struct rrd_pdp_prep) * head.ds_cnt +
- sizeof (struct rrd_cdp_prep) * head.ds_cnt * head.rra_cnt +
- sizeof (struct rrd_rra_ptr) * head.rra_cnt;
+ sizeof (struct rrd_ds_def) * head.ds_cnt +
+ sizeof (struct rrd_rra_def) * head.rra_cnt +
+ sizeof (struct rrd_live_head) +
+ sizeof (struct rrd_pdp_prep) * head.ds_cnt +
+ sizeof (struct rrd_cdp_prep) * head.ds_cnt * head.rra_cnt +
+ sizeof (struct rrd_rra_ptr) * head.rra_cnt;
if (st.st_size < (goffset)head_size) {
- g_set_error (err, rrd_error_quark (), errno, "rrd file seems to have stripped header: %d", head_size);
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd file seems to have stripped header: %d",
+ head_size);
close (fd);
return FALSE;
}
if (need_data) {
/* Now check rra */
- if (lseek (fd, sizeof (struct rrd_ds_def) * head.ds_cnt, SEEK_CUR) == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd head lseek error: %s", strerror (errno));
+ if (lseek (fd, sizeof (struct rrd_ds_def) * head.ds_cnt,
+ SEEK_CUR) == -1) {
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd head lseek error: %s",
+ strerror (errno));
close (fd);
return FALSE;
}
- for (i = 0; i < (gint)head.rra_cnt; i ++) {
+ for (i = 0; i < (gint)head.rra_cnt; i++) {
if (read (fd, &rra, sizeof (rra)) != sizeof (rra)) {
- g_set_error (err, rrd_error_quark (), errno, "rrd read rra error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd read rra error: %s",
+ strerror (errno));
close (fd);
return FALSE;
}
}
if (st.st_size != head_size) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd file seems to have incorrect size: %d, must be %d", (gint)st.st_size, head_size);
+ g_set_error (err,
+ rrd_error_quark (), EINVAL, "rrd file seems to have incorrect size: %d, must be %d",
+ (gint)st.st_size, head_size);
close (fd);
return FALSE;
}
static void
rspamd_rrd_adjust_pointers (struct rspamd_rrd_file *file, gboolean completed)
{
- guint8 *ptr;
+ guint8 *ptr;
ptr = file->map;
file->stat_head = (struct rrd_file_head *)ptr;
file->pdp_prep = (struct rrd_pdp_prep *)ptr;
ptr += sizeof (struct rrd_pdp_prep) * file->stat_head->ds_cnt;
file->cdp_prep = (struct rrd_cdp_prep *)ptr;
- ptr += sizeof (struct rrd_cdp_prep) * file->stat_head->rra_cnt * file->stat_head->ds_cnt;
+ ptr += sizeof (struct rrd_cdp_prep) * file->stat_head->rra_cnt *
+ file->stat_head->ds_cnt;
file->rra_ptr = (struct rrd_rra_ptr *)ptr;
if (completed) {
ptr += sizeof (struct rrd_rra_ptr) * file->stat_head->rra_cnt;
* @param err
* @return
*/
-static struct rspamd_rrd_file*
+static struct rspamd_rrd_file *
rspamd_rrd_open_common (const gchar *filename, gboolean completed, GError **err)
{
- struct rspamd_rrd_file *new;
- gint fd;
- struct stat st;
+ struct rspamd_rrd_file *new;
+ gint fd;
+ struct stat st;
if (!rspamd_rrd_check_file (filename, completed, err)) {
return NULL;
/* Open file */
fd = open (filename, O_RDWR);
if (fd == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
return FALSE;
}
if (fstat (fd, &st) == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
close (fd);
return FALSE;
}
/* Mmap file */
new->size = st.st_size;
- if ((new->map = mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((new->map =
+ mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
+ 0)) == MAP_FAILED) {
close (fd);
- g_set_error (err, rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
g_slice_free1 (sizeof (struct rspamd_rrd_file), new);
return NULL;
}
* @param err error pointer
* @return rrd file structure
*/
-struct rspamd_rrd_file*
+struct rspamd_rrd_file *
rspamd_rrd_open (const gchar *filename, GError **err)
{
return rspamd_rrd_open_common (filename, TRUE, err);
* @param err error pointer
* @return TRUE if file has been created
*/
-struct rspamd_rrd_file*
-rspamd_rrd_create (const gchar *filename, gulong ds_count, gulong rra_count, gulong pdp_step, GError **err)
+struct rspamd_rrd_file *
+rspamd_rrd_create (const gchar *filename,
+ gulong ds_count,
+ gulong rra_count,
+ gulong pdp_step,
+ GError **err)
{
- struct rspamd_rrd_file *new;
- struct rrd_file_head head;
- struct rrd_ds_def ds;
- struct rrd_rra_def rra;
- struct rrd_live_head lh;
- struct rrd_pdp_prep pdp;
- struct rrd_cdp_prep cdp;
- struct rrd_rra_ptr rra_ptr;
- gint fd;
- guint i, j;
- struct timeval tv;
+ struct rspamd_rrd_file *new;
+ struct rrd_file_head head;
+ struct rrd_ds_def ds;
+ struct rrd_rra_def rra;
+ struct rrd_live_head lh;
+ struct rrd_pdp_prep pdp;
+ struct rrd_cdp_prep cdp;
+ struct rrd_rra_ptr rra_ptr;
+ gint fd;
+ guint i, j;
+ struct timeval tv;
/* Open file */
fd = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
if (fd == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd create error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd create error: %s",
+ strerror (errno));
return NULL;
}
head.rra_cnt = rra_count;
head.ds_cnt = ds_count;
head.pdp_step = pdp_step;
- memcpy (head.cookie, RRD_COOKIE, sizeof (head.cookie));
+ memcpy (head.cookie, RRD_COOKIE, sizeof (head.cookie));
memcpy (head.version, RRD_VERSION, sizeof (head.version));
head.float_cookie = RRD_FLOAT_COOKIE;
if (write (fd, &head, sizeof (head)) != sizeof (head)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
return NULL;
}
memset (&ds.ds_nam, 0, sizeof (ds.ds_nam));
memcpy (&ds.dst, "COUNTER", sizeof ("COUNTER"));
memset (&ds.par, 0, sizeof (ds.par));
- for (i = 0; i < ds_count; i ++) {
+ for (i = 0; i < ds_count; i++) {
if (write (fd, &ds, sizeof (ds)) != sizeof (ds)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s",
+ strerror (errno));
return NULL;
}
}
memcpy (&rra.cf_nam, "AVERAGE", sizeof ("AVERAGE"));
rra.pdp_cnt = 1;
memset (&rra.par, 0, sizeof (rra.par));
- for (i = 0; i < rra_count; i ++) {
+ for (i = 0; i < rra_count; i++) {
if (write (fd, &rra, sizeof (rra)) != sizeof (rra)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s",
+ strerror (errno));
return NULL;
}
}
if (write (fd, &lh, sizeof (lh)) != sizeof (lh)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
return NULL;
}
memset (&pdp.scratch, 0, sizeof (pdp.scratch));
pdp.scratch[PDP_val].dv = 0.;
pdp.scratch[PDP_unkn_sec_cnt].lv = 0;
- for (i = 0; i < ds_count; i ++) {
+ for (i = 0; i < ds_count; i++) {
if (write (fd, &pdp, sizeof (pdp)) != sizeof (pdp)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s",
+ strerror (errno));
return NULL;
}
}
/* Fill cdp prep */
memset (&cdp.scratch, 0, sizeof (cdp.scratch));
cdp.scratch[CDP_val].dv = NAN;
- for (i = 0; i < rra_count; i ++) {
+ for (i = 0; i < rra_count; i++) {
cdp.scratch[CDP_unkn_pdp_cnt].lv = 0;
- for (j = 0; j < ds_count; j ++) {
+ for (j = 0; j < ds_count; j++) {
if (write (fd, &cdp, sizeof (cdp)) != sizeof (cdp)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s",
+ strerror (errno));
return NULL;
}
}
/* Set row pointers */
memset (&rra_ptr, 0, sizeof (rra_ptr));
- for (i = 0; i < rra_count; i ++) {
+ for (i = 0; i < rra_count; i++) {
if (write (fd, &rra_ptr, sizeof (rra_ptr)) != sizeof (rra_ptr)) {
close (fd);
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s",
+ strerror (errno));
return NULL;
}
}
rspamd_rrd_add_ds (struct rspamd_rrd_file *file, GArray *ds, GError **err)
{
- if (file == NULL || file->stat_head->ds_cnt * sizeof (struct rrd_ds_def) != ds->len) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd add ds failed: wrong arguments");
+ if (file == NULL || file->stat_head->ds_cnt * sizeof (struct rrd_ds_def) !=
+ ds->len) {
+ g_set_error (err,
+ rrd_error_quark (), EINVAL, "rrd add ds failed: wrong arguments");
return FALSE;
}
gboolean
rspamd_rrd_add_rra (struct rspamd_rrd_file *file, GArray *rra, GError **err)
{
- if (file == NULL || file->stat_head->rra_cnt * sizeof (struct rrd_rra_def) != rra->len) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
+ if (file == NULL || file->stat_head->rra_cnt *
+ sizeof (struct rrd_rra_def) != rra->len) {
+ g_set_error (err,
+ rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
return FALSE;
}
gboolean
rspamd_rrd_finalize (struct rspamd_rrd_file *file, GError **err)
{
- gint fd;
- guint i;
- gint count = 0;
- gdouble vbuf[1024];
- struct stat st;
+ gint fd;
+ guint i;
+ gint count = 0;
+ gdouble vbuf[1024];
+ struct stat st;
if (file == NULL || file->filename == NULL) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
+ g_set_error (err,
+ rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
return FALSE;
}
fd = open (file->filename, O_RDWR);
if (fd == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
return FALSE;
}
if (lseek (fd, 0, SEEK_END) == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd seek error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd seek error: %s", strerror (errno));
close (fd);
return FALSE;
}
/* Adjust CDP */
- for (i = 0; i < file->stat_head->rra_cnt; i ++) {
+ for (i = 0; i < file->stat_head->rra_cnt; i++) {
file->cdp_prep->scratch[CDP_unkn_pdp_cnt].lv = 0;
/* Randomize row pointer */
file->rra_ptr->cur_row = g_random_int () % file->rra_def[i].row_cnt;
munmap (file->map, file->size);
/* Write values */
- for (i = 0; i < G_N_ELEMENTS (vbuf); i ++) {
+ for (i = 0; i < G_N_ELEMENTS (vbuf); i++) {
vbuf[i] = NAN;
}
while (count > 0) {
/* Write values in buffered matter */
- if (write (fd, vbuf, MIN ((gint)G_N_ELEMENTS (vbuf), count) * sizeof (gdouble)) == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+ if (write (fd, vbuf,
+ MIN ((gint)G_N_ELEMENTS (vbuf), count) * sizeof (gdouble)) == -1) {
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd write error: %s",
+ strerror (errno));
close (fd);
return FALSE;
}
}
if (fstat (fd, &st) == -1) {
- g_set_error (err, rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
close (fd);
return FALSE;
}
/* Mmap again */
file->size = st.st_size;
- if ((file->map = mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((file->map =
+ mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
+ 0)) == MAP_FAILED) {
close (fd);
- g_set_error (err, rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
+ g_set_error (err,
+ rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
g_slice_free1 (sizeof (struct rspamd_rrd_file), file);
return FALSE;
}
* @return
*/
static gboolean
-rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file, gdouble *vals, gdouble *pdp_new, gdouble interval)
+rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file,
+ gdouble *vals,
+ gdouble *pdp_new,
+ gdouble interval)
{
- guint i;
- enum rrd_dst_type type;
+ guint i;
+ enum rrd_dst_type type;
- for (i = 0; i < file->stat_head->ds_cnt; i ++) {
+ for (i = 0; i < file->stat_head->ds_cnt; i++) {
type = rrd_dst_from_string (file->ds_def[i].dst);
if (file->ds_def[i].par[RRD_DS_mrhb_cnt].lv < interval) {
- rspamd_strlcpy (file->pdp_prep[i].last_ds, "U", sizeof (file->pdp_prep[i].last_ds));
+ rspamd_strlcpy (file->pdp_prep[i].last_ds, "U",
+ sizeof (file->pdp_prep[i].last_ds));
}
if (file->ds_def[i].par[RRD_DS_mrhb_cnt].lv >= interval) {
pdp_new[i] = NAN;
}
else {
- pdp_new[i] = vals[i] - strtod (file->pdp_prep[i].last_ds, NULL);
+ pdp_new[i] = vals[i] - strtod (file->pdp_prep[i].last_ds,
+ NULL);
}
break;
case RRD_DST_GAUGE:
}
/* Copy value to the last_ds */
if (!isnan (vals[i])) {
- rspamd_snprintf (file->pdp_prep[i].last_ds, sizeof (file->pdp_prep[i].last_ds), "%.4f", vals[i]);
+ rspamd_snprintf (file->pdp_prep[i].last_ds,
+ sizeof (file->pdp_prep[i].last_ds), "%.4f", vals[i]);
}
else {
file->pdp_prep[i].last_ds[0] = 'U';
* @param pdp_diff time till last pdp update
*/
static void
-rspamd_rrd_update_pdp_step (struct rspamd_rrd_file *file, gdouble *pdp_new, gdouble *pdp_temp, gdouble interval,
- gdouble pre_int, gdouble post_int, gulong pdp_diff)
+rspamd_rrd_update_pdp_step (struct rspamd_rrd_file *file,
+ gdouble *pdp_new,
+ gdouble *pdp_temp,
+ gdouble interval,
+ gdouble pre_int,
+ gdouble post_int,
+ gulong pdp_diff)
{
- guint i;
- rrd_value_t *scratch;
- gulong heartbeat;
+ guint i;
+ rrd_value_t *scratch;
+ gulong heartbeat;
- for (i = 0; i < file->stat_head->ds_cnt; i ++) {
+ for (i = 0; i < file->stat_head->ds_cnt; i++) {
scratch = file->pdp_prep[i].scratch;
heartbeat = file->ds_def[i].par[RRD_DS_mrhb_cnt].lv;
if (!isnan (pdp_new[i])) {
pre_int = 0.0;
}
/* Check interval value for heartbeat for this DS */
- if ((interval > heartbeat) || (file->stat_head->pdp_step / 2.0 < scratch[PDP_unkn_sec_cnt].lv)) {
+ if ((interval > heartbeat) ||
+ (file->stat_head->pdp_step / 2.0 < scratch[PDP_unkn_sec_cnt].lv)) {
pdp_temp[i] = NAN;
}
else {
pdp_temp[i] = scratch[PDP_val].dv /
- ((double) (pdp_diff - scratch[PDP_unkn_sec_cnt].lv) - pre_int);
+ ((double) (pdp_diff - scratch[PDP_unkn_sec_cnt].lv) - pre_int);
}
- if (isnan (pdp_new[i])) {
- scratch[PDP_unkn_sec_cnt].lv = floor (post_int);
- scratch[PDP_val].dv = NAN;
- } else {
- scratch[PDP_unkn_sec_cnt].lv = 0;
- scratch[PDP_val].dv = pdp_new[i] / interval * post_int;
- }
+ if (isnan (pdp_new[i])) {
+ scratch[PDP_unkn_sec_cnt].lv = floor (post_int);
+ scratch[PDP_val].dv = NAN;
+ } else {
+ scratch[PDP_unkn_sec_cnt].lv = 0;
+ scratch[PDP_val].dv = pdp_new[i] / interval * post_int;
+ }
}
}
* @param pdp_temp temporary pdp points
*/
static void
-rspamd_rrd_update_cdp (struct rspamd_rrd_file *file, gdouble pdp_steps, gdouble pdp_offset, gulong *rra_steps, gulong rra_index,
- gdouble *pdp_temp)
+rspamd_rrd_update_cdp (struct rspamd_rrd_file *file,
+ gdouble pdp_steps,
+ gdouble pdp_offset,
+ gulong *rra_steps,
+ gulong rra_index,
+ gdouble *pdp_temp)
{
- guint i;
- struct rrd_rra_def *rra;
- rrd_value_t *scratch;
- enum rrd_cf_type cf;
- gdouble last_cdp, cur_cdp;
- gulong pdp_in_cdp;
+ guint i;
+ struct rrd_rra_def *rra;
+ rrd_value_t *scratch;
+ enum rrd_cf_type cf;
+ gdouble last_cdp, cur_cdp;
+ gulong pdp_in_cdp;
rra = &file->rra_def[rra_index];
cf = rrd_cf_from_string (rra->cf_nam);
/* Iterate over all DS for this RRA */
- for (i = 0; i < file->stat_head->ds_cnt; i ++) {
+ for (i = 0; i < file->stat_head->ds_cnt; i++) {
/* Get CDP for this RRA and DS */
- scratch = file->cdp_prep[rra_index * file->stat_head->ds_cnt + i].scratch;
+ scratch =
+ file->cdp_prep[rra_index * file->stat_head->ds_cnt + i].scratch;
if (rra->pdp_cnt > 1) {
/* Do we have any CDP to update for this rra ? */
if (rra_steps[rra_index] > 0) {
}
/* Check XFF for this rra */
- if (scratch[CDP_unkn_pdp_cnt].lv > rra->pdp_cnt * rra->par[RRA_cdp_xff_val].lv) {
+ if (scratch[CDP_unkn_pdp_cnt].lv > rra->pdp_cnt *
+ rra->par[RRA_cdp_xff_val].lv) {
/* XFF is reached */
scratch[CDP_primary_val].dv = NAN;
}
/* Need to initialize CDP using specified consolidation */
switch (cf) {
case RRD_CF_AVERAGE:
- last_cdp = isnan (scratch[CDP_val].dv) ? 0.0 : scratch[CDP_val].dv;
+ last_cdp =
+ isnan (scratch[CDP_val].dv) ? 0.0 : scratch[CDP_val]
+ .dv;
cur_cdp = isnan (pdp_temp[i]) ? 0.0 : pdp_temp[i];
- scratch[CDP_primary_val].dv = (last_cdp + cur_cdp * pdp_offset) / (rra->pdp_cnt - scratch[CDP_unkn_pdp_cnt].lv);
+ scratch[CDP_primary_val].dv =
+ (last_cdp + cur_cdp *
+ pdp_offset) /
+ (rra->pdp_cnt - scratch[CDP_unkn_pdp_cnt].lv);
break;
case RRD_CF_MAXIMUM:
- last_cdp = isnan (scratch[CDP_val].dv) ? -INFINITY : scratch[CDP_val].dv;
+ last_cdp =
+ isnan (scratch[CDP_val].dv) ? -INFINITY : scratch[
+ CDP_val].dv;
cur_cdp = isnan (pdp_temp[i]) ? -INFINITY : pdp_temp[i];
scratch[CDP_primary_val].dv = MAX (last_cdp, cur_cdp);
break;
case RRD_CF_MINIMUM:
- last_cdp = isnan (scratch[CDP_val].dv) ? INFINITY : scratch[CDP_val].dv;
+ last_cdp =
+ isnan (scratch[CDP_val].dv) ? INFINITY : scratch[
+ CDP_val].dv;
cur_cdp = isnan (pdp_temp[i]) ? INFINITY : pdp_temp[i];
scratch[CDP_primary_val].dv = MIN (last_cdp, cur_cdp);
break;
scratch[CDP_val].dv = pdp_temp[i] * pdp_steps;
}
else {
- scratch[CDP_val].dv = last_cdp + pdp_temp[i] * pdp_steps;
+ scratch[CDP_val].dv = last_cdp + pdp_temp[i] *
+ pdp_steps;
}
break;
case RRD_CF_MAXIMUM:
void
rspamd_rrd_write_rra (struct rspamd_rrd_file *file, gulong *rra_steps)
{
- guint i, j, scratch_idx, cdp_idx, k;
- struct rrd_rra_def *rra;
- gdouble *rra_row;
+ guint i, j, scratch_idx, cdp_idx, k;
+ struct rrd_rra_def *rra;
+ gdouble *rra_row;
/* Iterate over all RRA */
- for (i = 0; i < file->stat_head->rra_cnt; i ++) {
+ for (i = 0; i < file->stat_head->rra_cnt; i++) {
rra = &file->rra_def[i];
/* How much steps need to be updated */
- for (j = 0, scratch_idx = CDP_primary_val; j < rra_steps[i]; j ++, scratch_idx = CDP_secondary_val) {
+ for (j = 0, scratch_idx = CDP_primary_val;
+ j < rra_steps[i];
+ j++, scratch_idx = CDP_secondary_val) {
/* Move row ptr */
if (++file->rra_ptr[i].cur_row >= rra->row_cnt) {
file->rra_ptr[i].cur_row = 0;
}
/* Calculate seek */
- rra_row = file->rrd_value + (file->stat_head->ds_cnt * i + file->rra_ptr[i].cur_row);
+ rra_row = file->rrd_value +
+ (file->stat_head->ds_cnt * i + file->rra_ptr[i].cur_row);
/* Iterate over DS */
- for (k = 0; k < file->stat_head->ds_cnt; k ++) {
+ for (k = 0; k < file->stat_head->ds_cnt; k++) {
cdp_idx = i * file->stat_head->ds_cnt + k;
- memcpy (rra_row, &file->cdp_prep[cdp_idx].scratch[scratch_idx].dv, sizeof (gdouble));
- rra_row ++;
+ memcpy (rra_row,
+ &file->cdp_prep[cdp_idx].scratch[scratch_idx].dv,
+ sizeof (gdouble));
+ rra_row++;
}
}
}
* @return TRUE if a row has been added
*/
gboolean
-rspamd_rrd_add_record (struct rspamd_rrd_file* file, GArray *points, GError **err)
+rspamd_rrd_add_record (struct rspamd_rrd_file * file,
+ GArray *points,
+ GError **err)
{
- gdouble interval, *pdp_new, *pdp_temp, pre_int, post_int;
- guint i;
- gulong pdp_steps, cur_pdp_count, prev_pdp_step, cur_pdp_step,
- prev_pdp_age, cur_pdp_age, *rra_steps, pdp_offset;
- struct timeval tv;
-
- if (file == NULL || file->stat_head->ds_cnt * sizeof (gdouble) != points->len) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd add points failed: wrong arguments");
+ gdouble interval, *pdp_new, *pdp_temp, pre_int, post_int;
+ guint i;
+ gulong pdp_steps, cur_pdp_count, prev_pdp_step, cur_pdp_step,
+ prev_pdp_age, cur_pdp_age, *rra_steps, pdp_offset;
+ struct timeval tv;
+
+ if (file == NULL || file->stat_head->ds_cnt * sizeof (gdouble) !=
+ points->len) {
+ g_set_error (err,
+ rrd_error_quark (), EINVAL,
+ "rrd add points failed: wrong arguments");
return FALSE;
}
/* Get interval */
gettimeofday (&tv, NULL);
interval = (gdouble)(tv.tv_sec - file->live_head->last_up) +
- (gdouble)(tv.tv_usec - file->live_head->last_up_usec) / 1e6f;
+ (gdouble)(tv.tv_usec - file->live_head->last_up_usec) / 1e6f;
/* Update PDP preparation values */
pdp_new = g_malloc (sizeof (gdouble) * file->stat_head->ds_cnt);
/* How much steps need to be updated in each RRA */
rra_steps = g_malloc0 (sizeof (gulong) * file->stat_head->rra_cnt);
- if (!rspamd_rrd_update_pdp_prep (file, (gdouble *)points->data, pdp_new, interval)) {
- g_set_error (err, rrd_error_quark (), EINVAL, "rrd update pdp failed: wrong arguments");
+ if (!rspamd_rrd_update_pdp_prep (file, (gdouble *)points->data, pdp_new,
+ interval)) {
+ g_set_error (err,
+ rrd_error_quark (), EINVAL,
+ "rrd update pdp failed: wrong arguments");
g_free (pdp_new);
g_free (pdp_temp);
g_free (rra_steps);
/* Calculate elapsed steps */
/* Age in seconds for previous pdp store */
- prev_pdp_age = file->live_head->last_up % file->stat_head->pdp_step;
+ prev_pdp_age = file->live_head->last_up % file->stat_head->pdp_step;
/* Time in seconds for last pdp update */
prev_pdp_step = file->live_head->last_up - prev_pdp_age;
/* Age in seconds from current time to required pdp time */
cur_pdp_step = tv.tv_sec - cur_pdp_age;
if (cur_pdp_step > prev_pdp_step) {
- pre_int = (gdouble)(cur_pdp_step - file->live_head->last_up) - ((double)file->live_head->last_up_usec) / 1e6f;
+ pre_int =
+ (gdouble)(cur_pdp_step -
+ file->live_head->last_up) -
+ ((double)file->live_head->last_up_usec) / 1e6f;
post_int = (gdouble)cur_pdp_age + ((double)tv.tv_usec) / 1e6f;
}
else {
if (pdp_steps == 0) {
/* Simple update of pdp prep */
- for (i = 0; i < file->stat_head->ds_cnt; i ++) {
+ for (i = 0; i < file->stat_head->ds_cnt; i++) {
if (isnan (pdp_new[i])) {
/* Increment unknown period */
- file->pdp_prep[i].scratch[PDP_unkn_sec_cnt].lv += floor (interval);
+ file->pdp_prep[i].scratch[PDP_unkn_sec_cnt].lv += floor (
+ interval);
}
else {
if (isnan (file->pdp_prep[i].scratch[PDP_val].dv)) {
/* Complex update of PDP, CDP and RRA */
/* Update PDP for this step */
- rspamd_rrd_update_pdp_step (file, pdp_new, pdp_temp, interval, pre_int, post_int, pdp_steps * file->stat_head->pdp_step);
+ rspamd_rrd_update_pdp_step (file,
+ pdp_new,
+ pdp_temp,
+ interval,
+ pre_int,
+ post_int,
+ pdp_steps * file->stat_head->pdp_step);
/* Update CDP points for each RRA*/
- for (i = 0; i < file->stat_head->rra_cnt; i ++) {
+ for (i = 0; i < file->stat_head->rra_cnt; i++) {
/* Calculate pdp offset for this RRA */
- pdp_offset = file->rra_def[i].pdp_cnt - cur_pdp_count % file->rra_def[i].pdp_cnt;
+ pdp_offset = file->rra_def[i].pdp_cnt - cur_pdp_count %
+ file->rra_def[i].pdp_cnt;
/* How much steps we got for this RRA */
if (pdp_offset <= pdp_steps) {
- rra_steps[i] = (pdp_steps - pdp_offset) / file->rra_def[i].pdp_cnt + 1;
+ rra_steps[i] =
+ (pdp_steps - pdp_offset) / file->rra_def[i].pdp_cnt + 1;
}
else {
/* This rra have not passed enough pdp steps */
rra_steps[i] = 0;
}
/* Update this specific CDP */
- rspamd_rrd_update_cdp (file, pdp_steps, pdp_offset, rra_steps, i, pdp_temp);
+ rspamd_rrd_update_cdp (file,
+ pdp_steps,
+ pdp_offset,
+ rra_steps,
+ i,
+ pdp_temp);
/* Write RRA */
rspamd_rrd_write_rra (file, rra_steps);
}
* @return
*/
gint
-rspamd_rrd_close (struct rspamd_rrd_file* file)
+rspamd_rrd_close (struct rspamd_rrd_file * file)
{
if (file == NULL) {
errno = EINVAL;
struct rrd_file_head {
/* Data Base Identification Section ** */
- gchar cookie[4]; /* RRD */
- gchar version[5]; /* version of the format */
- gdouble float_cookie; /* is it the correct double representation ? */
+ gchar cookie[4]; /* RRD */
+ gchar version[5]; /* version of the format */
+ gdouble float_cookie; /* is it the correct double representation ? */
/* Data Base Structure Definition **** */
gulong ds_cnt; /* how many different ds provid input to the rrd */
gulong rra_cnt; /* how many rras will be maintained in the rrd */
gulong pdp_step; /* pdp interval in seconds */
- rrd_value_t par[10]; /* global parameters ... unused
- at the moment */
+ rrd_value_t par[10]; /* global parameters ... unused
+ at the moment */
};
enum rrd_dst_type {
RRD_DS_mrhb_cnt = 0, /* minimum required heartbeat */
RRD_DS_min_val, /* the processed input of a ds must */
RRD_DS_max_val, /* be between max_val and min_val
- * both can be set to UNKNOWN if you
- * do not care. Data outside the limits
- * set to UNKNOWN */
+ * both can be set to UNKNOWN if you
+ * do not care. Data outside the limits
+ * set to UNKNOWN */
RRD_DS_cdef = RRD_DS_mrhb_cnt
}; /* pointer to encoded rpn expression only applies to DST_CDEF */
enum rrd_rra_param {
RRA_cdp_xff_val = 0, /* what part of the consolidated
- * datapoint must be known, to produce a
- * valid entry in the rra */
+ * datapoint must be known, to produce a
+ * valid entry in the rra */
/* CF_HWPREDICT: */
RRA_hw_alpha = 1,
/* exponential smoothing parameter for the intercept in
/* RRA_dependent_rra_idx = 3, */
RRA_window_len = 4,
RRA_failure_threshold = 5
- /* For CF_FAILURES, number of violations within the last
- * window required to mark a failure. */
+ /* For CF_FAILURES, number of violations within the last
+ * window required to mark a failure. */
};
#define RRD_CF_NAM_SIZE 20
struct rrd_rra_def {
- gchar cf_nam[RRD_CF_NAM_SIZE]; /* consolidation function (null term) */
+ gchar cf_nam[RRD_CF_NAM_SIZE]; /* consolidation function (null term) */
gulong row_cnt; /* number of entries in the store */
gulong pdp_cnt; /* how many primary data points are
- * required for a consolidated data point?*/
+ * required for a consolidated data point?*/
rrd_value_t par[MAX_RRA_PAR_EN]; /* index see rra_param_en */
};
enum rrd_pdp_param {
PDP_unkn_sec_cnt = 0, /* how many seconds of the current
- * pdp value is unknown data? */
+ * pdp value is unknown data? */
PDP_val
}; /* current value of the pdp.
this depends on dst */
struct rrd_pdp_prep {
gchar last_ds[RRD_LAST_DS_LEN]; /* the last reading from the data
- * source. this is stored in ASCII
- * to cater for very large counters
- * we might encounter in connection
- * with SNMP. */
+ * source. this is stored in ASCII
+ * to cater for very large counters
+ * we might encounter in connection
+ * with SNMP. */
rrd_value_t scratch[10]; /* contents according to pdp_par_en */
};
};
struct rrd_cdp_prep {
- rrd_value_t scratch[RRD_MAX_CDP_PAR_EN];
- /* contents according to cdp_par_en *
- * init state should be NAN */
+ rrd_value_t scratch[RRD_MAX_CDP_PAR_EN];
+ /* contents according to cdp_par_en *
+ * init state should be NAN */
};
struct rrd_rra_ptr {
gdouble *rrd_value; /* list of rrd values */
gchar *filename;
- guint8* map; /* mmapped area */
+ guint8 * map; /* mmapped area */
gsize size; /* its size */
gboolean finalized;
};
* @param err error pointer
* @return rrd file structure
*/
-struct rspamd_rrd_file* rspamd_rrd_open (const gchar *filename, GError **err);
+struct rspamd_rrd_file * rspamd_rrd_open (const gchar *filename, GError **err);
/**
* Create basic header for rrd file
* @param err error pointer
* @return TRUE if file has been created
*/
-struct rspamd_rrd_file* rspamd_rrd_create (const gchar *filename, gulong ds_count, gulong rra_count, gulong pdp_step, GError **err);
+struct rspamd_rrd_file * rspamd_rrd_create (const gchar *filename,
+ gulong ds_count,
+ gulong rra_count,
+ gulong pdp_step,
+ GError **err);
/**
* Add data sources to rrd file
* @param err error pointer
* @return TRUE if data sources were added
*/
-gboolean rspamd_rrd_add_ds (struct rspamd_rrd_file* file, GArray *ds, GError **err);
+gboolean rspamd_rrd_add_ds (struct rspamd_rrd_file * file,
+ GArray *ds,
+ GError **err);
/**
* Add round robin archives to rrd file
* @param err error pointer
* @return TRUE if archives were added
*/
-gboolean rspamd_rrd_add_rra (struct rspamd_rrd_file *file, GArray *rra, GError **err);
+gboolean rspamd_rrd_add_rra (struct rspamd_rrd_file *file,
+ GArray *rra,
+ GError **err);
/**
* Finalize rrd file header and initialize all RRA in the file
* @param err error pointer
* @return TRUE if a row has been added
*/
-gboolean rspamd_rrd_add_record (struct rspamd_rrd_file* file, GArray *points, GError **err);
+gboolean rspamd_rrd_add_record (struct rspamd_rrd_file * file,
+ GArray *points,
+ GError **err);
/**
* Close rrd file
* @param file
* @return
*/
-gint rspamd_rrd_close (struct rspamd_rrd_file* file);
+gint rspamd_rrd_close (struct rspamd_rrd_file * file);
/*
* Conversion functions
/**
* Convert numeric presentation of dst to string
*/
-const gchar* rrd_dst_to_string (enum rrd_dst_type type);
+const gchar * rrd_dst_to_string (enum rrd_dst_type type);
/**
* Convert rrd consolidation function type from string to numeric value
*/
/**
* Convert numeric presentation of cf to string
*/
-const gchar* rrd_cf_to_string (enum rrd_cf_type type);
+const gchar * rrd_cf_to_string (enum rrd_cf_type type);
/* Default RRA and DS */
/**
* Create default RRA
*/
-void rrd_make_default_rra (const gchar *cf_name, gulong pdp_cnt, gulong rows, struct rrd_rra_def *rra);
+void rrd_make_default_rra (const gchar *cf_name,
+ gulong pdp_cnt,
+ gulong rows,
+ struct rrd_rra_def *rra);
/**
* Create default DS
*/
-void rrd_make_default_ds (const gchar *name, gulong pdp_step, struct rrd_ds_def *ds);
+void rrd_make_default_ds (const gchar *name,
+ gulong pdp_step,
+ struct rrd_ds_def *ds);
#endif /* RRD_H_ */
#include "mem_pool.h"
#include "trie.h"
-rspamd_trie_t*
+rspamd_trie_t *
rspamd_trie_create (gboolean icase)
{
- rspamd_trie_t *new;
+ rspamd_trie_t *new;
new = g_malloc (sizeof (rspamd_trie_t));
* Insert a single character as the specified level of the suffix tree
*/
static struct rspamd_trie_state *
-rspamd_trie_insert_char (rspamd_trie_t *trie, guint depth, struct rspamd_trie_state *pos, gchar c)
+rspamd_trie_insert_char (rspamd_trie_t *trie,
+ guint depth,
+ struct rspamd_trie_state *pos,
+ gchar c)
{
- struct rspamd_trie_match *new_match;
- struct rspamd_trie_state *new_pos;
+ struct rspamd_trie_match *new_match;
+ struct rspamd_trie_state *new_pos;
/* New match is inserted before pos */
- new_match = rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_match));
+ new_match =
+ rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_match));
new_match->next = pos->match;
new_match->c = c;
/* Now set match link */
pos->match = new_match;
- new_match->state = rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_state));
+ new_match->state =
+ rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_state));
new_pos = new_match->state;
new_pos->match = NULL;
new_pos->fail = &trie->root;
static inline struct rspamd_trie_match *
check_match (struct rspamd_trie_state *s, gchar c)
{
- struct rspamd_trie_match *match = s->match;
+ struct rspamd_trie_match *match = s->match;
while (match && match->c != c) {
match = match->next;
void
rspamd_trie_insert (rspamd_trie_t *trie, const gchar *pattern, gint pattern_id)
{
- const guchar *p = pattern;
- struct rspamd_trie_state *q, *q1, *r, *cur_node;
- struct rspamd_trie_match *m, *n;
- guint i, depth = 0;
- gchar c;
+ const guchar *p = pattern;
+ struct rspamd_trie_state *q, *q1, *r, *cur_node;
+ struct rspamd_trie_match *m, *n;
+ guint i, depth = 0;
+ gchar c;
/* Insert pattern to the trie */
else {
cur_node = m->state;
}
- p ++;
- depth ++;
+ p++;
+ depth++;
}
cur_node->final = depth;
}
}
-const gchar*
-rspamd_trie_lookup (rspamd_trie_t *trie, const gchar *buffer, gsize buflen, gint *matched_id)
+const gchar *
+rspamd_trie_lookup (rspamd_trie_t *trie,
+ const gchar *buffer,
+ gsize buflen,
+ gint *matched_id)
{
- const guchar *p = buffer, *prev, *ret;
- struct rspamd_trie_state *cur_node;
- struct rspamd_trie_match *m = NULL;
- gchar c;
+ const guchar *p = buffer, *prev, *ret;
+ struct rspamd_trie_state *cur_node;
+ struct rspamd_trie_match *m = NULL;
+ gchar c;
cur_node = &trie->root;
/* We have tried the pattern but eventually it was not found */
cur_node = &trie->root;
ret = p;
- p ++;
+ p++;
prev = p;
- buflen --;
+ buflen--;
continue;
}
return (const gchar *) ret;
}
}
- p ++;
+ p++;
prev = p;
- buflen --;
+ buflen--;
}
return NULL;
/*
* Create a new suffix trie
*/
-rspamd_trie_t* rspamd_trie_create (gboolean icase);
+rspamd_trie_t * rspamd_trie_create (gboolean icase);
/*
* Insert a pattern into the trie
* @param pattern text of element
* @param pattern_id id of element
*/
-void rspamd_trie_insert (rspamd_trie_t *trie, const gchar *pattern, gint pattern_id);
+void rspamd_trie_insert (rspamd_trie_t *trie,
+ const gchar *pattern,
+ gint pattern_id);
/*
* Search for a text using suffix trie
* @param mached_id on a successfull search here would be stored id of pattern found
* @return Position in a text where pattern was found or NULL if no patterns were found
*/
-const gchar* rspamd_trie_lookup (rspamd_trie_t *trie, const gchar *buffer, gsize buflen, gint *matched_id);
+const gchar * rspamd_trie_lookup (rspamd_trie_t *trie,
+ const gchar *buffer,
+ gsize buflen,
+ gint *matched_id);
/*
* Deallocate suffix trie
#ifdef _THREAD_SAFE
-pthread_rwlock_t upstream_mtx = PTHREAD_RWLOCK_INITIALIZER;
+pthread_rwlock_t upstream_mtx = PTHREAD_RWLOCK_INITIALIZER;
# define U_RLOCK() do { pthread_rwlock_rdlock (&upstream_mtx); } while (0)
# define U_WLOCK() do { pthread_rwlock_wrlock (&upstream_mtx); } while (0)
# define U_UNLOCK() do { pthread_rwlock_unlock (&upstream_mtx); } while (0)
* Init: 0x0
*/
-static const guint32 crc32lookup[256] = {
- 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, 0x706af48fU,
- 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU, 0x97d2d988U,
- 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U,
- 0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U,
- 0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U,
- 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, 0xa2677172U,
- 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, 0x35b5a8faU, 0x42b2986cU,
- 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U,
- 0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U,
- 0xcfba9599U, 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U,
- 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U, 0x01db7106U,
- 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, 0x9fbfe4a5U, 0xe8b8d433U,
- 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU,
- 0x91646c97U, 0xe6635c01U, 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU,
- 0x6c0695edU, 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U,
- 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U, 0xfbd44c65U,
- 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, 0x4adfa541U, 0x3dd895d7U,
- 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, 0x346ed9fcU, 0xad678846U, 0xda60b8d0U,
- 0x44042d73U, 0x33031de5U, 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU,
- 0xbe0b1010U, 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU,
- 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U, 0x2eb40d81U,
- 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, 0x03b6e20cU, 0x74b1d29aU,
- 0xead54739U, 0x9dd277afU, 0x04db2615U, 0x73dc1683U, 0xe3630b12U, 0x94643b84U,
- 0x0d6d6a3eU, 0x7a6a5aa8U, 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U,
- 0xf00f9344U, 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU,
- 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU, 0x67dd4accU,
- 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, 0xd6d6a3e8U, 0xa1d1937eU,
- 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU,
- 0xd80d2bdaU, 0xaf0a1b4cU, 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U,
- 0x316e8eefU, 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U,
- 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU, 0xb2bd0b28U,
- 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, 0x2cd99e8bU, 0x5bdeae1dU,
- 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU,
- 0x72076785U, 0x05005713U, 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U,
- 0x92d28e9bU, 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U,
- 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U, 0x18b74777U,
- 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, 0x8f659effU, 0xf862ae69U,
- 0x616bffd3U, 0x166ccf45U, 0xa00ae278U, 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U,
- 0xa7672661U, 0xd06016f7U, 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU,
- 0x40df0b66U, 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U,
- 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U, 0xcdd70693U,
- 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, 0x5d681b02U, 0x2a6f2b94U,
+static const guint32 crc32lookup[256] = {
+ 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U,
+ 0x706af48fU,
+ 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU,
+ 0x97d2d988U,
+ 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U, 0x1db71064U,
+ 0x6ab020f2U,
+ 0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U,
+ 0x83d385c7U,
+ 0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU,
+ 0x63066cd9U,
+ 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U,
+ 0xa2677172U,
+ 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, 0x35b5a8faU,
+ 0x42b2986cU,
+ 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU,
+ 0xabd13d59U,
+ 0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U,
+ 0x56b3c423U,
+ 0xcfba9599U, 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U,
+ 0xb10be924U,
+ 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U,
+ 0x01db7106U,
+ 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, 0x9fbfe4a5U,
+ 0xe8b8d433U,
+ 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, 0xe10e9818U, 0x7f6a0dbbU,
+ 0x086d3d2dU,
+ 0x91646c97U, 0xe6635c01U, 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U,
+ 0xf262004eU,
+ 0x6c0695edU, 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U,
+ 0x12b7e950U,
+ 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U,
+ 0xfbd44c65U,
+ 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, 0x4adfa541U,
+ 0x3dd895d7U,
+ 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, 0x346ed9fcU, 0xad678846U,
+ 0xda60b8d0U,
+ 0x44042d73U, 0x33031de5U, 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU,
+ 0x270241aaU,
+ 0xbe0b1010U, 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U,
+ 0xce61e49fU,
+ 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U,
+ 0x2eb40d81U,
+ 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, 0x03b6e20cU,
+ 0x74b1d29aU,
+ 0xead54739U, 0x9dd277afU, 0x04db2615U, 0x73dc1683U, 0xe3630b12U,
+ 0x94643b84U,
+ 0x0d6d6a3eU, 0x7a6a5aa8U, 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U,
+ 0x7d079eb1U,
+ 0xf00f9344U, 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU,
+ 0x806567cbU,
+ 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU,
+ 0x67dd4accU,
+ 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, 0xd6d6a3e8U,
+ 0xa1d1937eU,
+ 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, 0xa6bc5767U, 0x3fb506ddU,
+ 0x48b2364bU,
+ 0xd80d2bdaU, 0xaf0a1b4cU, 0x36034af6U, 0x41047a60U, 0xdf60efc3U,
+ 0xa867df55U,
+ 0x316e8eefU, 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U,
+ 0x5268e236U,
+ 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU,
+ 0xb2bd0b28U,
+ 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, 0x2cd99e8bU,
+ 0x5bdeae1dU,
+ 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, 0x026d930aU, 0x9c0906a9U,
+ 0xeb0e363fU,
+ 0x72076785U, 0x05005713U, 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU,
+ 0x0cb61b38U,
+ 0x92d28e9bU, 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U,
+ 0xf1d4e242U,
+ 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U,
+ 0x18b74777U,
+ 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, 0x8f659effU,
+ 0xf862ae69U,
+ 0x616bffd3U, 0x166ccf45U, 0xa00ae278U, 0xd70dd2eeU, 0x4e048354U,
+ 0x3903b3c2U,
+ 0xa7672661U, 0xd06016f7U, 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU,
+ 0xd9d65adcU,
+ 0x40df0b66U, 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU,
+ 0x30b5ffe9U,
+ 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U,
+ 0xcdd70693U,
+ 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, 0x5d681b02U,
+ 0x2a6f2b94U,
0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU, 0x2d02ef8dU
};
* Check upstream parameters and mark it whether valid or dead
*/
static void
-check_upstream (struct upstream *up, time_t now, time_t error_timeout, time_t revive_timeout, size_t max_errors)
+check_upstream (struct upstream *up,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors)
{
if (up->dead) {
if (now - up->time >= revive_timeout) {
}
}
-/*
+/*
* Call this function after failed upstream request
*/
void
}
}
-/*
+/*
* Call this function after successfull upstream request
*/
void
up->weight--;
}
-/*
+/*
* Mark all upstreams as active. This function is used when all upstreams are marked as inactive
*/
void
revive_all_upstreams (void *ups, size_t members, size_t msize)
{
- guint i;
- struct upstream *cur;
- guchar *p;
+ guint i;
+ struct upstream *cur;
+ guchar *p;
U_WLOCK ();
p = ups;
U_UNLOCK ();
}
-/*
+/*
* Scan all upstreams for errors and mark upstreams dead or alive depends on conditions,
- * return number of alive upstreams
+ * return number of alive upstreams
*/
static gint
-rescan_upstreams (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout, time_t revive_timeout, size_t max_errors)
+rescan_upstreams (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors)
{
- guint i, alive;
- struct upstream *cur;
- guchar *p;
+ guint i, alive;
+ struct upstream *cur;
+ guchar *p;
/* Recheck all upstreams */
p = ups;
}
/* Return alive upstream by its number */
-static struct upstream *
+static struct upstream *
get_upstream_by_number (void *ups, size_t members, size_t msize, gint selected)
{
- guint i;
- u_char *p, *c;
- struct upstream *cur;
+ guint i;
+ u_char *p, *c;
+ struct upstream *cur;
i = 0;
p = ups;
c = ups;
U_RLOCK ();
- for (;;) {
+ for (;; ) {
/* Out of range, return NULL */
if (p > c + members * msize) {
break;
/*
* Get hash key for specified key (perl hash)
*/
-static guint32
+static guint32
get_hash_for_key (guint32 hash, const gchar *key, size_t keylen)
{
- guint32 h, index;
- const gchar *end = key + keylen;
+ guint32 h, index;
+ const gchar *end = key + keylen;
h = ~hash;
/*
* Recheck all upstreams and return random active upstream
*/
-struct upstream *
-get_random_upstream (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors)
+struct upstream *
+get_random_upstream (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors)
{
- gint alive, selected;
-
- alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
+ gint alive, selected;
+
+ alive = rescan_upstreams (ups,
+ members,
+ msize,
+ now,
+ error_timeout,
+ revive_timeout,
+ max_errors);
selected = rand () % alive;
return get_upstream_by_number (ups, members, msize, selected);
/*
* Return upstream by hash, that is calculated from active upstreams number
*/
-struct upstream *
-get_upstream_by_hash (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors, const gchar *key, size_t keylen)
+struct upstream *
+get_upstream_by_hash (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors,
+ const gchar *key,
+ size_t keylen)
{
- gint alive, tries = 0, r;
- guint32 h = 0, ht;
- gchar *p, numbuf[4];
- struct upstream *cur;
-
- alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
+ gint alive, tries = 0, r;
+ guint32 h = 0, ht;
+ gchar *p, numbuf[4];
+ struct upstream *cur;
+
+ alive = rescan_upstreams (ups,
+ members,
+ msize,
+ now,
+ error_timeout,
+ revive_timeout,
+ max_errors);
if (alive == 0) {
return NULL;
#endif
h %= members;
- for (;;) {
+ for (;; ) {
p = (gchar *)ups + msize * h;
cur = (struct upstream *)p;
if (!cur->dead) {
/*
* Recheck all upstreams and return upstream in round-robin order according to weight and priority
*/
-struct upstream *
-get_upstream_round_robin (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors)
+struct upstream *
+get_upstream_round_robin (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors)
{
- guint max_weight, i;
- struct upstream *cur, *selected = NULL;
- u_char *p;
+ guint max_weight, i;
+ struct upstream *cur, *selected = NULL;
+ u_char *p;
/* Recheck all upstreams */
- (void)rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
+ (void)rescan_upstreams (ups,
+ members,
+ msize,
+ now,
+ error_timeout,
+ revive_timeout,
+ max_errors);
p = ups;
max_weight = 0;
/*
* Recheck all upstreams and return upstream in round-robin order according to only priority (master-slaves)
*/
-struct upstream *
-get_upstream_master_slave (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors)
+struct upstream *
+get_upstream_master_slave (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors)
{
- guint max_weight, i;
- struct upstream *cur, *selected = NULL;
- u_char *p;
+ guint max_weight, i;
+ struct upstream *cur, *selected = NULL;
+ u_char *p;
/* Recheck all upstreams */
- (void)rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
+ (void)rescan_upstreams (ups,
+ members,
+ msize,
+ now,
+ error_timeout,
+ revive_timeout,
+ max_errors);
p = ups;
max_weight = 0;
* Add ketama points for specified upstream
*/
gint
-upstream_ketama_add (struct upstream *up, gchar *up_key, size_t keylen, size_t keypoints)
+upstream_ketama_add (struct upstream *up,
+ gchar *up_key,
+ size_t keylen,
+ size_t keypoints)
{
- guint32 h = 0;
- gchar tmp[4];
- guint i;
+ guint32 h = 0;
+ gchar tmp[4];
+ guint i;
/* Allocate ketama points array */
if (up->ketama_points == NULL) {
/*
* Return upstream by hash and find nearest ketama point in some server
*/
-struct upstream *
-get_upstream_by_hash_ketama (void *ups, size_t members, size_t msize,
- time_t now, time_t error_timeout, time_t revive_timeout, size_t max_errors, const gchar *key, size_t keylen)
+struct upstream *
+get_upstream_by_hash_ketama (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors,
+ const gchar *key,
+ size_t keylen)
{
- guint alive, i;
- guint32 h = 0, step, middle, d, min_diff = UINT_MAX;
- gchar *p;
- struct upstream *cur = NULL, *nearest = NULL;
-
- alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
+ guint alive, i;
+ guint32 h = 0, step, middle, d, min_diff = UINT_MAX;
+ gchar *p;
+ struct upstream *cur = NULL, *nearest = NULL;
+
+ alive = rescan_upstreams (ups,
+ members,
+ msize,
+ now,
+ error_timeout,
+ revive_timeout,
+ max_errors);
if (alive == 0) {
return NULL;
#undef U_LOCK
#undef U_UNLOCK
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
#ifndef UPSTREAM_H
#define UPSTREAM_H
-#include <sys/types.h>
#include <stdint.h>
+#include <sys/types.h>
/**
* Structure of generic upstream
*/
struct upstream {
- guint errors; /**< Errors for this upstream */
- time_t time; /**< Time of marking */
- guint dead; /**< Dead flag */
- guint priority; /**< Fixed priority */
- gint16 weight; /**< Dynamic weight */
- guint32 *ketama_points; /**< Ketama points array */
- size_t ketama_points_size; /**< Ketama array size */
+ guint errors; /**< Errors for this upstream */
+ time_t time; /**< Time of marking */
+ guint dead; /**< Dead flag */
+ guint priority; /**< Fixed priority */
+ gint16 weight; /**< Dynamic weight */
+ guint32 *ketama_points; /**< Ketama points array */
+ size_t ketama_points_size; /**< Ketama array size */
};
/**
/**
* Add ketama points for upstream
*/
-gint upstream_ketama_add (struct upstream *up, gchar *up_key, size_t keylen, size_t keypoints);
+gint upstream_ketama_add (struct upstream *up,
+ gchar *up_key,
+ size_t keylen,
+ size_t keypoints);
/**
* Get a random upstream from array of upstreams
* @param revive_timeout time during which we counts upstream dead
* @param max_errors maximum errors during error_timeout to mark upstream dead
*/
-struct upstream* get_random_upstream (void *ups, size_t members, size_t msize,
- time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors);
+struct upstream * get_random_upstream (void *ups, size_t members, size_t msize,
+ time_t now, time_t error_timeout,
+ time_t revive_timeout, size_t max_errors);
/**
* Get upstream based on hash from array of upstreams
* @param key key for hashing
* @param keylen length of the key
*/
-struct upstream* get_upstream_by_hash (void *ups, size_t members, size_t msize,
- time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors,
- const gchar *key, size_t keylen);
+struct upstream * get_upstream_by_hash (void *ups, size_t members, size_t msize,
+ time_t now, time_t error_timeout,
+ time_t revive_timeout, size_t max_errors,
+ const gchar *key, size_t keylen);
/**
* Get an upstream from array of upstreams based on its current weight
* @param revive_timeout time during which we counts upstream dead
* @param max_errors maximum errors during error_timeout to mark upstream dead
*/
-struct upstream* get_upstream_round_robin (void *ups, size_t members, size_t msize,
- time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors);
+struct upstream * get_upstream_round_robin (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors);
/**
* Get upstream based on hash from array of upstreams, this functions is using ketama algorithm
* @param key key for hashing
* @param keylen length of the key
*/
-struct upstream* get_upstream_by_hash_ketama (void *ups, size_t members, size_t msize, time_t now,
- time_t error_timeout, time_t revive_timeout, size_t max_errors,
- const gchar *key, size_t keylen);
+struct upstream * get_upstream_by_hash_ketama (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors,
+ const gchar *key,
+ size_t keylen);
/**
* Get an upstream from array of upstreams based on its current priority (not weight)
* @param revive_timeout time during which we counts upstream dead
* @param max_errors maximum errors during error_timeout to mark upstream dead
*/
-struct upstream* get_upstream_master_slave (void *ups, size_t members, size_t msize,
- time_t now, time_t error_timeout,
- time_t revive_timeout, size_t max_errors);
+struct upstream * get_upstream_master_slave (void *ups,
+ size_t members,
+ size_t msize,
+ time_t now,
+ time_t error_timeout,
+ time_t revive_timeout,
+ size_t max_errors);
#endif /* UPSTREAM_H */
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
*/
-#include "config.h"
-#include "util.h"
#include "cfg_file.h"
-#include "main.h"
-#include "statfile.h"
+#include "config.h"
#include "filter.h"
+#include "main.h"
#include "message.h"
+#include "statfile.h"
+#include "util.h"
#ifdef HAVE_OPENSSL
-#include <openssl/rand.h>
#include <openssl/err.h>
+#include <openssl/rand.h>
#endif
#ifdef HAVE_TERMIOS_H
gint
make_socket_nonblocking (gint fd)
{
- gint ofl;
+ gint ofl;
ofl = fcntl (fd, F_GETFL, 0);
gint
make_socket_blocking (gint fd)
{
- gint ofl;
+ gint ofl;
ofl = fcntl (fd, F_GETFL, 0);
gint
poll_sync_socket (gint fd, gint timeout, short events)
{
- gint r;
- struct pollfd fds[1];
+ gint r;
+ struct pollfd fds[1];
fds->fd = fd;
fds->events = events;
static gint
make_inet_socket (gint type, struct addrinfo *addr, gboolean is_server,
- gboolean async, GList **list)
+ gboolean async, GList **list)
{
- gint fd, r, optlen, on = 1, s_error;
- struct addrinfo *cur;
+ gint fd, r, optlen, on = 1, s_error;
+ struct addrinfo *cur;
cur = addr;
while (cur) {
}
if (is_server) {
- setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (gint));
+ setsockopt (fd,
+ SOL_SOCKET,
+ SO_REUSEADDR,
+ (const void *)&on,
+ sizeof (gint));
#ifdef HAVE_IPV6_V6ONLY
if (cur->ai_family == AF_INET6) {
- setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, (const void *)&on, sizeof (gint));
+ setsockopt (fd,
+ IPPROTO_IPV6,
+ IPV6_V6ONLY,
+ (const void *)&on,
+ sizeof (gint));
}
#endif
r = bind (fd, cur->ai_addr, cur->ai_addrlen);
if (r == -1) {
if (errno != EINPROGRESS) {
- msg_warn ("bind/connect failed: %d, '%s'", errno, strerror (errno));
+ msg_warn ("bind/connect failed: %d, '%s'", errno,
+ strerror (errno));
goto out;
}
if (!async) {
/* Try to poll */
- if (poll_sync_socket (fd, CONNECT_TIMEOUT * 1000, POLLOUT) <= 0) {
+ if (poll_sync_socket (fd, CONNECT_TIMEOUT * 1000,
+ POLLOUT) <= 0) {
errno = ETIMEDOUT;
msg_warn ("bind/connect failed: timeout");
goto out;
}
gint
-make_unix_socket (const gchar *path, struct sockaddr_un *addr, gint type, gboolean is_server, gboolean async)
+make_unix_socket (const gchar *path,
+ struct sockaddr_un *addr,
+ gint type,
+ gboolean is_server,
+ gboolean async)
{
- gint fd = -1, s_error, r, optlen, serrno, on = 1;
- struct stat st;
+ gint fd = -1, s_error, r, optlen, serrno, on = 1;
+ struct stat st;
if (path == NULL)
return -1;
if (lstat (addr->sun_path, &st) != -1) {
if (S_ISSOCK (st.st_mode)) {
if (unlink (addr->sun_path) == -1) {
- msg_warn ("unlink %s failed: %d, '%s'", addr->sun_path, errno, strerror (errno));
+ msg_warn ("unlink %s failed: %d, '%s'",
+ addr->sun_path,
+ errno,
+ strerror (errno));
goto out;
}
}
fd = socket (PF_LOCAL, type, 0);
if (fd == -1) {
- msg_warn ("socket failed %s: %d, '%s'", addr->sun_path, errno, strerror (errno));
+ msg_warn ("socket failed %s: %d, '%s'",
+ addr->sun_path,
+ errno,
+ strerror (errno));
return -1;
}
/* Set close on exec */
if (fcntl (fd, F_SETFD, FD_CLOEXEC) == -1) {
- msg_warn ("fcntl failed %s: %d, '%s'", addr->sun_path, errno, strerror (errno));
+ msg_warn ("fcntl failed %s: %d, '%s'", addr->sun_path, errno,
+ strerror (errno));
goto out;
}
if (is_server) {
- setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (gint));
+ setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on,
+ sizeof (gint));
r = bind (fd, (struct sockaddr *)addr, SUN_LEN (addr));
}
else {
if (r == -1) {
if (errno != EINPROGRESS) {
- msg_warn ("bind/connect failed %s: %d, '%s'", addr->sun_path, errno, strerror (errno));
+ msg_warn ("bind/connect failed %s: %d, '%s'",
+ addr->sun_path,
+ errno,
+ strerror (errno));
goto out;
}
if (!async) {
return (fd);
- out:
+out:
serrno = errno;
if (fd != -1) {
close (fd);
*/
gint
make_universal_socket (const gchar *credits, guint16 port,
- gint type, gboolean async, gboolean is_server, gboolean try_resolve)
+ gint type, gboolean async, gboolean is_server, gboolean try_resolve)
{
- struct sockaddr_un un;
- struct stat st;
- struct addrinfo hints, *res;
- gint r;
- gchar portbuf[8];
+ struct sockaddr_un un;
+ struct stat st;
+ struct addrinfo hints, *res;
+ gint r;
+ gchar portbuf[8];
if (*credits == '/') {
if (is_server) {
return -1;
}
else {
- return make_unix_socket (credits, &un, type, is_server, async);
+ return make_unix_socket (credits,
+ &un,
+ type,
+ is_server,
+ async);
}
}
}
return r;
}
else {
- msg_err ("address resolution for %s failed: %s", credits, gai_strerror (r));
+ msg_err ("address resolution for %s failed: %s",
+ credits,
+ gai_strerror (r));
return FALSE;
}
}
* @param is_server make this socket as server socket
* @param try_resolve try name resolution for a socket (BLOCKING)
*/
-GList*
+GList *
make_universal_sockets_list (const gchar *credits, guint16 port,
- gint type, gboolean async, gboolean is_server, gboolean try_resolve)
+ gint type, gboolean async, gboolean is_server, gboolean try_resolve)
{
- struct sockaddr_un un;
- struct stat st;
- struct addrinfo hints, *res;
- gint r, fd, serrno;
- gchar portbuf[8], **strv, **cur;
- GList *result = NULL, *rcur;
+ struct sockaddr_un un;
+ struct stat st;
+ struct addrinfo hints, *res;
+ gint r, fd, serrno;
+ gchar portbuf[8], **strv, **cur;
+ GList *result = NULL, *rcur;
strv = g_strsplit_set (credits, ",", -1);
if (strv == NULL) {
goto err;
}
else {
- fd = make_unix_socket (credits, &un, type, is_server, async);
+ fd = make_unix_socket (credits,
+ &un,
+ type,
+ is_server,
+ async);
}
}
}
}
}
else {
- msg_err ("address resolution for %s failed: %s", credits, gai_strerror (r));
+ msg_err ("address resolution for %s failed: %s",
+ credits,
+ gai_strerror (r));
goto err;
}
}
- cur ++;
+ cur++;
}
g_strfreev (strv);
gint
make_socketpair (gint pair[2])
{
- gint r;
+ gint r;
r = socketpair (AF_LOCAL, SOCK_STREAM, 0, pair);
if (r == -1) {
- msg_warn ("socketpair failed: %d, '%s'", errno, strerror (errno), pair[0], pair[1]);
+ msg_warn ("socketpair failed: %d, '%s'", errno, strerror (
+ errno), pair[0], pair[1]);
return -1;
}
/* Set close on exec */
gint
write_pid (struct rspamd_main *main)
{
- pid_t pid;
+ pid_t pid;
if (main->cfg->pid_file == NULL) {
return -1;
#else
if (fchown (main->pfh->pf_fd, 0, 0) == -1) {
#endif
- msg_err ("cannot chown of pidfile %s to 0:0 user", main->cfg->pid_file);
+ msg_err ("cannot chown of pidfile %s to 0:0 user",
+ main->cfg->pid_file);
}
}
#ifdef HAVE_SA_SIGINFO
void
-init_signals (struct sigaction *signals, void (*sig_handler)(gint, siginfo_t *, void *))
+init_signals (struct sigaction *signals, void (*sig_handler)(gint,
+ siginfo_t *,
+ void *))
#else
void
init_signals (struct sigaction *signals, void (*sig_handler)(gint))
#endif
{
- struct sigaction sigpipe_act;
+ struct sigaction sigpipe_act;
/* Setting up signal handlers */
/* SIGUSR1 - reopen config file */
/* SIGUSR2 - worker is ready for accept */
signals->sa_flags = 0;
#endif
sigaction (SIGTERM, signals, NULL);
- sigaction (SIGINT, signals, NULL);
- sigaction (SIGHUP, signals, NULL);
+ sigaction (SIGINT, signals, NULL);
+ sigaction (SIGHUP, signals, NULL);
sigaction (SIGCHLD, signals, NULL);
sigaction (SIGUSR1, signals, NULL);
sigaction (SIGUSR2, signals, NULL);
static void
pass_signal_cb (gpointer key, gpointer value, gpointer ud)
{
- struct rspamd_worker *cur = value;
- gint signo = GPOINTER_TO_INT (ud);
+ struct rspamd_worker *cur = value;
+ gint signo = GPOINTER_TO_INT (ud);
kill (cur->pid, signo);
}
void
pass_signal_worker (GHashTable * workers, gint signo)
{
- g_hash_table_foreach (workers, pass_signal_cb, GINT_TO_POINTER (signo));
+ g_hash_table_foreach (workers, pass_signal_cb, GINT_TO_POINTER (signo));
}
void
#ifndef HAVE_SETPROCTITLE
-static gchar *title_buffer = 0;
-static size_t title_buffer_size = 0;
-static gchar *title_progname, *title_progname_full;
+static gchar *title_buffer = 0;
+static size_t title_buffer_size = 0;
+static gchar *title_progname, *title_progname_full;
gint
setproctitle (const gchar *fmt, ...)
memset (title_buffer, '\0', title_buffer_size);
- ssize_t written;
+ ssize_t written;
if (fmt) {
- ssize_t written2;
- va_list ap;
+ ssize_t written2;
+ va_list ap;
- written = snprintf (title_buffer, title_buffer_size, "%s: ", title_progname);
+ written = snprintf (title_buffer,
+ title_buffer_size,
+ "%s: ",
+ title_progname);
if (written < 0 || (size_t) written >= title_buffer_size)
return -1;
va_start (ap, fmt);
- written2 = vsnprintf (title_buffer + written, title_buffer_size - written, fmt, ap);
+ written2 = vsnprintf (title_buffer + written,
+ title_buffer_size - written,
+ fmt,
+ ap);
va_end (ap);
if (written2 < 0 || (size_t) written2 >= title_buffer_size - written)
return -1;
}
else {
- written = snprintf (title_buffer, title_buffer_size, "%s", title_progname);
+ written = snprintf (title_buffer,
+ title_buffer_size,
+ "%s",
+ title_progname);
if (written < 0 || (size_t) written >= title_buffer_size)
return -1;
}
}
/*
- It has to be _init function, because __attribute__((constructor))
- functions gets called without arguments.
-*/
+ It has to be _init function, because __attribute__((constructor))
+ functions gets called without arguments.
+ */
gint
init_title (gint argc, gchar *argv[], gchar *envp[])
/* XXX: try to handle these OSes too */
return 0;
#else
- gchar *begin_of_buffer = 0, *end_of_buffer = 0;
- gint i;
+ gchar *begin_of_buffer = 0, *end_of_buffer = 0;
+ gint i;
for (i = 0; i < argc; ++i) {
if (!begin_of_buffer)
if (!end_of_buffer)
return 0;
- gchar **new_environ = g_malloc ((i + 1) * sizeof (envp[0]));
+ gchar **new_environ = g_malloc ((i + 1) * sizeof (envp[0]));
if (!new_environ)
return 0;
if (!title_progname_full)
goto cleanup_enomem;
- gchar *p = strrchr (title_progname_full, '/');
+ gchar *p = strrchr (title_progname_full, '/');
if (p)
title_progname = p + 1;
return 0;
- cleanup_enomem:
+cleanup_enomem:
for (--i; i >= 0; --i) {
g_free (new_environ[i]);
}
#endif
#ifndef HAVE_PIDFILE
-extern gchar *__progname;
-static gint _rspamd_pidfile_remove (rspamd_pidfh_t *pfh, gint freeit);
+extern gchar *__progname;
+static gint _rspamd_pidfile_remove (rspamd_pidfh_t *pfh, gint freeit);
static gint
rspamd_pidfile_verify (rspamd_pidfh_t *pfh)
{
- struct stat sb;
+ struct stat sb;
if (pfh == NULL || pfh->pf_fd == -1)
return (-1);
static gint
rspamd_pidfile_read (const gchar *path, pid_t * pidptr)
{
- gchar buf[16], *endptr;
- gint error, fd, i;
+ gchar buf[16], *endptr;
+ gint error, fd, i;
fd = open (path, O_RDONLY);
if (fd == -1)
return (errno);
i = read (fd, buf, sizeof (buf) - 1);
- error = errno; /* Remember errno in case close() wants to change it. */
+ error = errno; /* Remember errno in case close() wants to change it. */
close (fd);
if (i == -1)
return error;
return 0;
}
-rspamd_pidfh_t *
+rspamd_pidfh_t *
rspamd_pidfile_open (const gchar *path, mode_t mode, pid_t * pidptr)
{
- rspamd_pidfh_t *pfh;
- struct stat sb;
- gint error, fd, len, count;
- struct timespec rqtp;
+ rspamd_pidfh_t *pfh;
+ struct stat sb;
+ gint error, fd, len, count;
+ struct timespec rqtp;
pfh = g_malloc (sizeof (*pfh));
if (pfh == NULL)
return NULL;
if (path == NULL)
- len = snprintf (pfh->pf_path, sizeof (pfh->pf_path), "/var/run/%s.pid", g_get_prgname ());
+ len = snprintf (pfh->pf_path,
+ sizeof (pfh->pf_path),
+ "/var/run/%s.pid",
+ g_get_prgname ());
else
len = snprintf (pfh->pf_path, sizeof (pfh->pf_path), "%s", path);
if (len >= (gint)sizeof (pfh->pf_path)) {
rqtp.tv_sec = 0;
rqtp.tv_nsec = 5000000;
if (errno == EWOULDBLOCK && pidptr != NULL) {
- again:
+again:
errno = rspamd_pidfile_read (pfh->pf_path, pidptr);
if (errno == 0)
errno = EEXIST;
gint
rspamd_pidfile_write (rspamd_pidfh_t *pfh)
{
- gchar pidstr[16];
- gint error, fd;
+ gchar pidstr[16];
+ gint error, fd;
/*
* Check remembered descriptor, so we don't overwrite some other
gint
rspamd_pidfile_close (rspamd_pidfh_t *pfh)
{
- gint error;
+ gint error;
error = rspamd_pidfile_verify (pfh);
if (error != 0) {
static gint
_rspamd_pidfile_remove (rspamd_pidfh_t *pfh, gint freeit)
{
- gint error;
+ gint error;
error = rspamd_pidfile_verify (pfh);
if (error != 0) {
#endif
/* Replace %r with rcpt value and %f with from value, new string is allocated in pool */
-gchar *
-resolve_stat_filename (rspamd_mempool_t * pool, gchar *pattern, gchar *rcpt, gchar *from)
+gchar *
+resolve_stat_filename (rspamd_mempool_t * pool,
+ gchar *pattern,
+ gchar *rcpt,
+ gchar *from)
{
- gint need_to_format = 0, len = 0;
- gint rcptlen, fromlen;
- gchar *c = pattern, *new, *s;
+ gint need_to_format = 0, len = 0;
+ gint rcptlen, fromlen;
+ gchar *c = pattern, *new, *s;
if (rcpt) {
rcptlen = strlen (rcpt);
}
#ifdef HAVE_CLOCK_GETTIME
-const gchar *
-calculate_check_time (struct timeval *tv, struct timespec *begin, gint resolution, guint32 *scan_time)
+const gchar *
+calculate_check_time (struct timeval *tv,
+ struct timespec *begin,
+ gint resolution,
+ guint32 *scan_time)
#else
-const gchar *
-calculate_check_time (struct timeval *begin, gint resolution, guint32 *scan_time)
+const gchar *
+calculate_check_time (struct timeval *begin, gint resolution,
+ guint32 *scan_time)
#endif
{
- double vdiff, diff;
- static gchar res[64];
- static gchar fmt[sizeof ("%.10f ms real, %.10f ms virtual")];
- struct timeval tv_now;
+ double vdiff, diff;
+ static gchar res[64];
+ static gchar fmt[sizeof ("%.10f ms real, %.10f ms virtual")];
+ struct timeval tv_now;
if (gettimeofday (&tv_now, NULL) == -1) {
msg_warn ("gettimeofday failed: %s", strerror (errno));
}
#ifdef HAVE_CLOCK_GETTIME
- struct timespec ts;
+ struct timespec ts;
- diff = (tv_now.tv_sec - tv->tv_sec) * 1000. + /* Seconds */
- (tv_now.tv_usec - tv->tv_usec) / 1000.; /* Microseconds */
+ diff = (tv_now.tv_sec - tv->tv_sec) * 1000. + /* Seconds */
+ (tv_now.tv_usec - tv->tv_usec) / 1000.; /* Microseconds */
#ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts);
#elif defined(HAVE_CLOCK_VIRTUAL)
- clock_gettime (CLOCK_VIRTUAL, &ts);
+ clock_gettime (CLOCK_VIRTUAL, &ts);
#else
- clock_gettime (CLOCK_REALTIME, &ts);
+ clock_gettime (CLOCK_REALTIME, &ts);
#endif
- vdiff = (ts.tv_sec - begin->tv_sec) * 1000. + /* Seconds */
- (ts.tv_nsec - begin->tv_nsec) / 1000000.; /* Nanoseconds */
+ vdiff = (ts.tv_sec - begin->tv_sec) * 1000. + /* Seconds */
+ (ts.tv_nsec - begin->tv_nsec) / 1000000.; /* Nanoseconds */
#else
- diff = (tv_now.tv_sec - begin->tv_sec) * 1000. + /* Seconds */
- (tv_now.tv_usec - begin->tv_usec) / 1000.; /* Microseconds */
+ diff = (tv_now.tv_sec - begin->tv_sec) * 1000. + /* Seconds */
+ (tv_now.tv_usec - begin->tv_usec) / 1000.; /* Microseconds */
vdiff = diff;
#endif
guint
rspamd_strcase_hash (gconstpointer key)
{
- const gchar *p = key;
- gchar buf[256];
- guint h = 0, i = 0;
+ const gchar *p = key;
+ gchar buf[256];
+ guint h = 0, i = 0;
while (*p != '\0') {
guint
rspamd_str_hash (gconstpointer key)
{
- gsize len;
+ gsize len;
len = strlen ((const gchar *)key);
fstr_strcase_equal (gconstpointer v, gconstpointer v2)
{
const f_str_t *f1 = v, *f2 = v2;
- if (f1->len == f2->len && g_ascii_strncasecmp (f1->begin, f2->begin, f1->len) == 0) {
+ if (f1->len == f2->len &&
+ g_ascii_strncasecmp (f1->begin, f2->begin, f1->len) == 0) {
return TRUE;
}
guint
fstr_strcase_hash (gconstpointer key)
{
- const f_str_t *f = key;
- const gchar *p;
- guint h = 0, i = 0;
- gchar buf[256];
-
+ const f_str_t *f = key;
+ const gchar *p;
+ guint h = 0, i = 0;
+ gchar buf[256];
+
p = f->begin;
while (p - f->begin < (gint)f->len) {
buf[i] = g_ascii_tolower (*p);
gperf_profiler_init (struct rspamd_config *cfg, const gchar *descr)
{
#if defined(WITH_GPERF_TOOLS)
- gchar prof_path[PATH_MAX];
+ gchar prof_path[PATH_MAX];
if (getenv ("CPUPROFILE")) {
}
/* Try to create temp directory for gmon.out and chdir to it */
if (cfg->profile_path == NULL) {
- cfg->profile_path = g_strdup_printf ("%s/rspamd-profile", cfg->temp_dir);
+ cfg->profile_path =
+ g_strdup_printf ("%s/rspamd-profile", cfg->temp_dir);
}
- snprintf (prof_path, sizeof (prof_path), "%s-%s.%d", cfg->profile_path, descr, (gint)getpid ());
+ snprintf (prof_path,
+ sizeof (prof_path),
+ "%s-%s.%d",
+ cfg->profile_path,
+ descr,
+ (gint)getpid ());
if (ProfilerStart (prof_path)) {
/* start ITIMER_PROF timer */
ProfilerRegisterThread ();
#ifdef HAVE_FLOCK
/* Flock version */
-gboolean
+gboolean
lock_file (gint fd, gboolean async)
{
- gint flags;
+ gint flags;
- if (async) {
- flags = LOCK_EX | LOCK_NB;
- }
- else {
- flags = LOCK_EX;
- }
+ if (async) {
+ flags = LOCK_EX | LOCK_NB;
+ }
+ else {
+ flags = LOCK_EX;
+ }
- if (flock (fd, flags) == -1) {
- if (async && errno == EAGAIN) {
- return FALSE;
- }
- msg_warn ("lock on file failed: %s", strerror (errno));
- return FALSE;
- }
+ if (flock (fd, flags) == -1) {
+ if (async && errno == EAGAIN) {
+ return FALSE;
+ }
+ msg_warn ("lock on file failed: %s", strerror (errno));
+ return FALSE;
+ }
- return TRUE;
+ return TRUE;
}
-gboolean
+gboolean
unlock_file (gint fd, gboolean async)
{
- gint flags;
+ gint flags;
- if (async) {
- flags = LOCK_UN | LOCK_NB;
- }
- else {
- flags = LOCK_UN;
- }
+ if (async) {
+ flags = LOCK_UN | LOCK_NB;
+ }
+ else {
+ flags = LOCK_UN;
+ }
- if (flock (fd, flags) == -1) {
- if (async && errno == EAGAIN) {
- return FALSE;
- }
- msg_warn ("lock on file failed: %s", strerror (errno));
- return FALSE;
- }
+ if (flock (fd, flags) == -1) {
+ if (async && errno == EAGAIN) {
+ return FALSE;
+ }
+ msg_warn ("lock on file failed: %s", strerror (errno));
+ return FALSE;
+ }
- return TRUE;
+ return TRUE;
}
#else /* HAVE_FLOCK */
/* Fctnl version */
-gboolean
+gboolean
lock_file (gint fd, gboolean async)
{
- struct flock fl = {
- .l_type = F_WRLCK,
- .l_whence = SEEK_SET,
- .l_start = 0,
- .l_len = 0
- };
+ struct flock fl = {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ .l_start = 0,
+ .l_len = 0
+ };
- if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
- if (async && (errno == EAGAIN || errno == EACCES)) {
- return FALSE;
- }
- msg_warn ("lock on file failed: %s", strerror (errno));
- return FALSE;
- }
+ if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
+ if (async && (errno == EAGAIN || errno == EACCES)) {
+ return FALSE;
+ }
+ msg_warn ("lock on file failed: %s", strerror (errno));
+ return FALSE;
+ }
- return TRUE;
+ return TRUE;
}
-gboolean
+gboolean
unlock_file (gint fd, gboolean async)
{
- struct flock fl = {
- .l_type = F_UNLCK,
- .l_whence = SEEK_SET,
- .l_start = 0,
- .l_len = 0
- };
+ struct flock fl = {
+ .l_type = F_UNLCK,
+ .l_whence = SEEK_SET,
+ .l_start = 0,
+ .l_len = 0
+ };
- if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
- if (async && (errno == EAGAIN || errno == EACCES)) {
- return FALSE;
- }
- msg_warn ("lock on file failed: %s", strerror (errno));
- return FALSE;
- }
+ if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
+ if (async && (errno == EAGAIN || errno == EACCES)) {
+ return FALSE;
+ }
+ msg_warn ("lock on file failed: %s", strerror (errno));
+ return FALSE;
+ }
- return TRUE;
+ return TRUE;
}
#endif /* HAVE_FLOCK */
gint
compare_email_func (gconstpointer a, gconstpointer b)
{
- const struct uri *u1 = a, *u2 = b;
- gint r;
+ const struct uri *u1 = a, *u2 = b;
+ gint r;
if (u1->hostlen != u2->hostlen || u1->hostlen == 0) {
return u1->hostlen - u2->hostlen;
}
else {
- if ((r = g_ascii_strncasecmp (u1->host, u2->host, u1->hostlen)) == 0){
+ if ((r = g_ascii_strncasecmp (u1->host, u2->host, u1->hostlen)) == 0) {
if (u1->userlen != u2->userlen || u1->userlen == 0) {
return u1->userlen - u2->userlen;
}
gint
compare_url_func (gconstpointer a, gconstpointer b)
{
- const struct uri *u1 = a, *u2 = b;
- int r;
+ const struct uri *u1 = a, *u2 = b;
+ int r;
if (u1->hostlen != u2->hostlen || u1->hostlen == 0) {
return u1->hostlen - u2->hostlen;
gchar *
rspamd_strncasestr (const gchar *s, const gchar *find, gint len)
{
- gchar c, sc;
- gsize mlen;
+ gchar c, sc;
+ gsize mlen;
if ((c = *find++) != 0) {
c = g_ascii_tolower (c);
mlen = strlen (find);
do {
do {
- if ((sc = *s++) == 0 || len -- == 0)
+ if ((sc = *s++) == 0 || len-- == 0)
return (NULL);
} while (g_ascii_tolower (sc) != c);
} while (g_ascii_strncasecmp (s, find, mlen) != 0);
gboolean
rspamd_strtol (const gchar *s, gsize len, glong *value)
{
- const gchar *p = s, *end = s + len;
- gchar c;
- glong v = 0;
- const glong cutoff = G_MAXLONG / 10, cutlim = G_MAXLONG % 10;
- gboolean neg;
+ const gchar *p = s, *end = s + len;
+ gchar c;
+ glong v = 0;
+ const glong cutoff = G_MAXLONG / 10, cutlim = G_MAXLONG % 10;
+ gboolean neg;
/* Case negative values */
if (*p == '-') {
neg = TRUE;
- p ++;
+ p++;
}
else {
neg = FALSE;
else {
return FALSE;
}
- p ++;
+ p++;
}
*value = neg ? -(v) : v;
gboolean
rspamd_strtoul (const gchar *s, gsize len, gulong *value)
{
- const gchar *p = s, *end = s + len;
- gchar c;
- gulong v = 0;
- const gulong cutoff = G_MAXULONG / 10, cutlim = G_MAXULONG % 10;
+ const gchar *p = s, *end = s + len;
+ gchar c;
+ gulong v = 0;
+ const gulong cutoff = G_MAXULONG / 10, cutlim = G_MAXULONG % 10;
/* Some preparations for range errors */
while (p < end) {
else {
return FALSE;
}
- p ++;
+ p++;
}
*value = v;
* Create new mutex
* @return mutex or NULL
*/
-inline rspamd_mutex_t*
+inline rspamd_mutex_t *
rspamd_mutex_new (void)
{
- rspamd_mutex_t *new;
+ rspamd_mutex_t *new;
new = g_slice_alloc (sizeof (rspamd_mutex_t));
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION > 30))
* Create new rwlock
* @return
*/
-rspamd_rwlock_t*
+rspamd_rwlock_t *
rspamd_rwlock_new (void)
{
- rspamd_rwlock_t *new;
+ rspamd_rwlock_t *new;
new = g_malloc (sizeof (rspamd_rwlock_t));
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION > 30))
static gpointer
rspamd_thread_func (gpointer ud)
{
- struct rspamd_thread_data *td = ud;
- sigset_t s_mask;
+ struct rspamd_thread_data *td = ud;
+ sigset_t s_mask;
/* Ignore signals in thread */
sigemptyset (&s_mask);
* @param err error pointer
* @return new thread object that can be joined
*/
-GThread*
-rspamd_create_thread (const gchar *name, GThreadFunc func, gpointer data, GError **err)
+GThread *
+rspamd_create_thread (const gchar *name,
+ GThreadFunc func,
+ gpointer data,
+ GError **err)
{
- GThread *new;
- struct rspamd_thread_data *td;
- static gint32 id;
- guint r;
+ GThread *new;
+ struct rspamd_thread_data *td;
+ static gint32 id;
+ guint r;
r = strlen (name);
td = g_malloc (sizeof (struct rspamd_thread_data));
{
- const guint32 c1 = 0xcc9e2d51;
- const guint32 c2 = 0x1b873593;
+ const guint32 c1 = 0xcc9e2d51;
+ const guint32 c2 = 0x1b873593;
- const int nblocks = len / 4;
- const guint32 *blocks = (const guint32 *)(in);
- const guint8 *tail;
- guint32 h = 0;
- gint i;
- guint32 k;
+ const int nblocks = len / 4;
+ const guint32 *blocks = (const guint32 *)(in);
+ const guint8 *tail;
+ guint32 h = 0;
+ gint i;
+ guint32 k;
if (in == NULL || len == 0) {
return 0;
void
murmur128_hash (const guint8 *in, gsize len, guint64 out[])
{
- const guint64 c1 = 0x87c37b91114253d5ULL;
- const guint64 c2 = 0x4cf5ad432745937fULL;
- const gint nblocks = len / 16;
- const guint64 *blocks = (const guint64 *)(in);
- const guint8 *tail;
- guint64 h1 = 0;
- guint64 h2 = 0;
- int i;
- guint64 k1, k2;
+ const guint64 c1 = 0x87c37b91114253d5ULL;
+ const guint64 c2 = 0x4cf5ad432745937fULL;
+ const gint nblocks = len / 16;
+ const guint64 *blocks = (const guint64 *)(in);
+ const guint8 *tail;
+ guint64 h1 = 0;
+ guint64 h2 = 0;
+ int i;
+ guint64 k1, k2;
if (in == NULL || len == 0 || out == NULL) {
return;
tail = (const guint8 *)(in + (nblocks * 16));
for (i = 0; i < nblocks; i++) {
- k1 = blocks[i*2+0];
- k2 = blocks[i*2+1];
+ k1 = blocks[i * 2 + 0];
+ k2 = blocks[i * 2 + 1];
k1 *= c1;
- k1 = (k1 << 31) | (k1 >> (64 - 31));
+ k1 = (k1 << 31) | (k1 >> (64 - 31));
k1 *= c2;
h1 ^= k1;
h1 = (h1 << 27) | (h1 >> (64 - 27));
h1 += h2;
- h1 = h1*5+0x52dce729;
+ h1 = h1 * 5 + 0x52dce729;
k2 *= c2;
- k2 = (k2 << 33) | (k2 >> (64 - 33));
+ k2 = (k2 << 33) | (k2 >> (64 - 33));
k2 *= c1;
h2 ^= k2;
h2 = (h2 << 31) | (h2 >> (64 - 31));
h2 += h1;
- h2 = h2*5+0x38495ab5;
+ h2 = h2 * 5 + 0x38495ab5;
}
k1 = k2 = 0;
case 9:
k2 ^= (guint64)(tail[ 8]) << 0;
k2 *= c2;
- k2 = (k2 << 33) | (k2 >> (64 - 33));
+ k2 = (k2 << 33) | (k2 >> (64 - 33));
k2 *= c1;
h2 ^= k2;
case 1:
k1 ^= (guint64)(tail[ 0]) << 0;
k1 *= c1;
- k1 = (k1 << 31) | (k1 >> (64 - 31));
+ k1 = (k1 << 31) | (k1 >> (64 - 31));
k1 *= c2;
h1 ^= k1;
};
static void
copy_foreach_callback (gpointer key, gpointer value, gpointer ud)
{
- struct hash_copy_callback_data *cb = ud;
- gpointer nkey, nvalue;
+ struct hash_copy_callback_data *cb = ud;
+ gpointer nkey, nvalue;
nkey = cb->key_copy_func ? cb->key_copy_func (key, cb->ud) : (gpointer)key;
- nvalue = cb->value_copy_func ? cb->value_copy_func (value, cb->ud) : (gpointer)value;
+ nvalue =
+ cb->value_copy_func ? cb->value_copy_func (value,
+ cb->ud) : (gpointer)value;
g_hash_table_insert (cb->dst, nkey, nvalue);
}
/**
* @param value_copy_func function called to copy or modify values (or NULL)
* @param ud user data for copy functions
*/
-void rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
- gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
- gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
- gpointer ud)
+void
+rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
+ gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
+ gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
+ gpointer ud)
{
- struct hash_copy_callback_data cb;
+ struct hash_copy_callback_data cb;
if (src != NULL && dst != NULL) {
cb.key_copy_func = key_copy_func;
cb.value_copy_func = value_copy_func;
gpointer
rspamd_str_pool_copy (gconstpointer data, gpointer ud)
{
- rspamd_mempool_t *pool = ud;
+ rspamd_mempool_t *pool = ud;
return data ? rspamd_mempool_strdup (pool, data) : NULL;
}
bzero (ip_buf, sizeof (ip_buf));
if ((pos = strchr (line, '/')) != NULL) {
- rspamd_strlcpy (ip_buf, line, MIN ((gsize)(pos - line), sizeof (ip_buf)));
+ rspamd_strlcpy (ip_buf, line,
+ MIN ((gsize)(pos - line), sizeof (ip_buf)));
rspamd_strlcpy (mask_buf, pos + 1, sizeof (mask_buf));
}
else {
static volatile sig_atomic_t saved_signo[NSIG];
static
-void read_pass_tmp_sig_handler (int s)
+void
+read_pass_tmp_sig_handler (int s)
{
saved_signo[s] = 1;
gint len = 0;
gchar pass[BUFSIZ];
- if (readpassphrase ("Enter passphrase: ", buf, size, RPP_ECHO_OFF | RPP_REQUIRE_TTY) == NULL) {
+ if (readpassphrase ("Enter passphrase: ", buf, size, RPP_ECHO_OFF |
+ RPP_REQUIRE_TTY) == NULL) {
return 0;
}
errno = ENOTTY;
return 0;
}
- memcpy(&term, &oterm, sizeof(term));
+ memcpy (&term, &oterm, sizeof(term));
term.c_lflag &= ~(ECHO | ECHONL);
- (void)tcsetattr(input, TCSAFLUSH, &term);
- (void)write (output, "Enter passphrase: ", sizeof ("Enter passphrase: ") - 1);
+ (void)tcsetattr (input, TCSAFLUSH, &term);
+ (void)write (output, "Enter passphrase: ", sizeof ("Enter passphrase: ") -
+ 1);
/* Save the current sighandler */
for (i = 0; i < NSIG; i++) {
saved_signo[i] = 0;
}
- sigemptyset(&sa.sa_mask);
+ sigemptyset (&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = read_pass_tmp_sig_handler;
(void)sigaction (SIGALRM, &sa, &savealrm);
/* Restore terminal state */
if (memcmp (&term, &oterm, sizeof (term)) != 0) {
while (tcsetattr (input, TCSAFLUSH, &oterm) == -1 &&
- errno == EINTR && !saved_signo[SIGTTOU]);
+ errno == EINTR && !saved_signo[SIGTTOU]) ;
}
/* Restore signal handlers */
/* Send signals pending */
for (i = 0; i < NSIG; i++) {
if (saved_signo[i]) {
- kill(getpid(), i);
+ kill (getpid (), i);
switch (i) {
case SIGTSTP:
case SIGTTIN:
gboolean ret = FALSE;
if (G_LIKELY (addr->af == AF_INET)) {
- if (memcmp (&addr->addr.s4.sin_addr, &ip4_any, sizeof (struct in_addr)) != 0 &&
- memcmp (&addr->addr.s4.sin_addr, &ip4_none,
- sizeof (struct in_addr)) != 0) {
+ if (memcmp (&addr->addr.s4.sin_addr, &ip4_any,
+ sizeof (struct in_addr)) != 0 &&
+ memcmp (&addr->addr.s4.sin_addr, &ip4_none,
+ sizeof (struct in_addr)) != 0) {
ret = TRUE;
}
}
else if (G_UNLIKELY (addr->af == AF_INET6)) {
if (memcmp (&addr->addr.s6.sin6_addr, &ip6_any,
- sizeof (struct in6_addr)) != 0) {
+ sizeof (struct in6_addr)) != 0) {
ret = TRUE;
}
}
}
void
-rspamd_ucl_emit_gstring (ucl_object_t *obj, enum ucl_emitter emit_type, GString *target)
+rspamd_ucl_emit_gstring (ucl_object_t *obj,
+ enum ucl_emitter emit_type,
+ GString *target)
{
struct ucl_emitter_functions func = {
.ucl_emitter_append_character = rspamd_gstring_append_character,
return (nfd);
- out:
+out:
serrno = errno;
close (nfd);
errno = serrno;
return ret;
}
-const char*
+const char *
rspamd_inet_address_to_string (rspamd_inet_addr_t *addr)
{
static char addr_str[INET6_ADDRSTRLEN + 1];
switch (addr->af) {
case AF_INET:
return inet_ntop (addr->af, &addr->addr.s4.sin_addr, addr_str,
- sizeof (addr_str));
+ sizeof (addr_str));
case AF_INET6:
return inet_ntop (addr->af, &addr->addr.s6.sin6_addr, addr_str,
- sizeof (addr_str));
+ sizeof (addr_str));
case AF_UNIX:
return addr->addr.su.sun_path;
}
#define RSPAMD_UTIL_H
#include "config.h"
+#include "fstring.h"
#include "mem_pool.h"
-#include "statfile.h"
#include "printf.h"
-#include "fstring.h"
+#include "statfile.h"
#include "ucl.h"
struct rspamd_config;
/*
* Create and bind or connect unix socket
*/
-gint make_unix_socket (const gchar *, struct sockaddr_un *, gint type, gboolean is_server, gboolean async);
+gint make_unix_socket (const gchar *,
+ struct sockaddr_un *,
+ gint type,
+ gboolean is_server,
+ gboolean async);
/**
* Make a universal socket
* @param try_resolve try name resolution for a socket (BLOCKING)
*/
gint make_universal_socket (const gchar *credits, guint16 port, gint type,
- gboolean async, gboolean is_server, gboolean try_resolve);
+ gboolean async, gboolean is_server, gboolean try_resolve);
/**
* Make a universal sockets
* @param is_server make this socket as server socket
* @param try_resolve try name resolution for a socket (BLOCKING)
*/
-GList* make_universal_sockets_list (const gchar *credits, guint16 port, gint type,
- gboolean async, gboolean is_server, gboolean try_resolve);
+GList * make_universal_sockets_list (const gchar *credits,
+ guint16 port,
+ gint type,
+ gboolean async,
+ gboolean is_server,
+ gboolean try_resolve);
/*
* Create socketpair
*/
* Init signals
*/
#ifdef HAVE_SA_SIGINFO
-void init_signals (struct sigaction *sa, void (*sig_handler)(gint, siginfo_t *, void *));
+void init_signals (struct sigaction *sa, void (*sig_handler)(gint,
+ siginfo_t *,
+ void *));
#else
void init_signals (struct sigaction *sa, void (*sig_handler)(gint));
#endif
/*
* Process title utility functions
*/
-gint init_title(gint argc, gchar *argv[], gchar *envp[]);
-gint setproctitle(const gchar *fmt, ...);
+gint init_title (gint argc, gchar *argv[], gchar *envp[]);
+gint setproctitle (const gchar *fmt, ...);
#endif
#ifndef HAVE_PIDFILE
typedef struct rspamd_pidfh_s {
gint pf_fd;
#ifdef HAVE_PATH_MAX
- gchar pf_path[PATH_MAX + 1];
+ gchar pf_path[PATH_MAX + 1];
#elif defined(HAVE_MAXPATHLEN)
- gchar pf_path[MAXPATHLEN + 1];
+ gchar pf_path[MAXPATHLEN + 1];
#else
- gchar pf_path[1024 + 1];
+ gchar pf_path[1024 + 1];
#endif
- dev_t pf_dev;
- ino_t pf_ino;
+ dev_t pf_dev;
+ ino_t pf_ino;
} rspamd_pidfh_t;
-rspamd_pidfh_t *rspamd_pidfile_open(const gchar *path, mode_t mode, pid_t *pidptr);
-gint rspamd_pidfile_write(rspamd_pidfh_t *pfh);
-gint rspamd_pidfile_close(rspamd_pidfh_t *pfh);
-gint rspamd_pidfile_remove(rspamd_pidfh_t *pfh);
+rspamd_pidfh_t * rspamd_pidfile_open (const gchar *path,
+ mode_t mode,
+ pid_t *pidptr);
+gint rspamd_pidfile_write (rspamd_pidfh_t *pfh);
+gint rspamd_pidfile_close (rspamd_pidfh_t *pfh);
+gint rspamd_pidfile_remove (rspamd_pidfh_t *pfh);
#else
typedef struct pidfh rspamd_pidfh_t;
#define rspamd_pidfile_open pidfile_open
/*
* Replace %r with rcpt value and %f with from value, new string is allocated in pool
*/
-gchar* resolve_stat_filename (rspamd_mempool_t *pool, gchar *pattern, gchar *rcpt, gchar *from);
+gchar * resolve_stat_filename (rspamd_mempool_t *pool,
+ gchar *pattern,
+ gchar *rcpt,
+ gchar *from);
#ifdef HAVE_CLOCK_GETTIME
/*
* Calculate check time with specified resolution of timer
*/
-const gchar* calculate_check_time (struct timeval *tv, struct timespec *begin, gint resolution, guint32 *scan_ms);
+const gchar * calculate_check_time (struct timeval *tv,
+ struct timespec *begin,
+ gint resolution,
+ guint32 *scan_ms);
#else
-const gchar* calculate_check_time (struct timeval *begin, gint resolution, guint32 *scan_ms);
+const gchar * calculate_check_time (struct timeval *begin,
+ gint resolution,
+ guint32 *scan_ms);
#endif
/*
/*
* Convert milliseconds to timeval fields
*/
-#define msec_to_tv(msec, tv) do { (tv)->tv_sec = (msec) / 1000; (tv)->tv_usec = ((msec) - (tv)->tv_sec * 1000) * 1000; } while(0)
-#define double_to_tv(dbl, tv) do { (tv)->tv_sec = (int)(dbl); (tv)->tv_usec = ((dbl) - (int)(dbl))*1000*1000; } while(0)
+#define msec_to_tv(msec, tv) do { (tv)->tv_sec = (msec) / 1000; (tv)->tv_usec = \
+ ((msec) - (tv)->tv_sec * 1000) * 1000; \
+} while (0)
+#define double_to_tv(dbl, tv) do { (tv)->tv_sec = (int)(dbl); (tv)->tv_usec = \
+ ((dbl) - (int)(dbl)) * 1000 * 1000; \
+} while (0)
#define tv_to_msec(tv) (tv)->tv_sec * 1000 + (tv)->tv_usec / 1000
/* Compare two emails for building emails tree */
/*
* Find string find in string s ignoring case
*/
-gchar* rspamd_strncasestr (const gchar *s, const gchar *find, gint len);
+gchar * rspamd_strncasestr (const gchar *s, const gchar *find, gint len);
/*
* Try to convert string of length to long
* Create new mutex
* @return mutex or NULL
*/
-rspamd_mutex_t* rspamd_mutex_new (void);
+rspamd_mutex_t * rspamd_mutex_new (void);
/**
* Lock mutex
* Create new rwloc
* @return
*/
-rspamd_rwlock_t* rspamd_rwlock_new (void);
+rspamd_rwlock_t * rspamd_rwlock_new (void);
/**
* Lock rwlock for writing
* @param err error pointer
* @return new thread object that can be joined
*/
-GThread* rspamd_create_thread (const gchar *name, GThreadFunc func, gpointer data, GError **err);
+GThread * rspamd_create_thread (const gchar *name,
+ GThreadFunc func,
+ gpointer data,
+ GError **err);
/**
* Return 32bit murmur hash value for specified input
* @param ud user data for copy functions
*/
void rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
- gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
- gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
- gpointer ud);
+ gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
+ gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
+ gpointer ud);
/**
* Utility function to provide mem_pool copy for rspamd_hash_table_copy function
* @param emit_type emitter type
* @param target target string
*/
-void rspamd_ucl_emit_gstring (ucl_object_t *obj, enum ucl_emitter emit_type, GString *target);
+void rspamd_ucl_emit_gstring (ucl_object_t *obj,
+ enum ucl_emitter emit_type,
+ GString *target);
/**
* Accept from listening socket filling addr structure
* @param src IP string representation
* @return TRUE if addr has been parsed
*/
-gboolean rspamd_parse_inet_address (rspamd_inet_addr_t *target, const char *src);
+gboolean rspamd_parse_inet_address (rspamd_inet_addr_t *target,
+ const char *src);
/**
* Returns string representation of inet address
* @param addr
* @return statically allocated string pointer (not thread safe)
*/
-const char* rspamd_inet_address_to_string (rspamd_inet_addr_t *addr);
+const char * rspamd_inet_address_to_string (rspamd_inet_addr_t *addr);
/**
* Returns port number for the specified inet address in host byte order
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
#include "buffer.h"
-#include "main.h"
+#include "cfg_file.h"
+#include "config.h"
#include "lmtp.h"
#include "lmtp_proto.h"
-#include "cfg_file.h"
-#include "util.h"
-#include "url.h"
+#include "main.h"
#include "message.h"
+#include "url.h"
+#include "util.h"
-static gchar greetingbuf[1024];
-static struct timeval io_tv;
+static gchar greetingbuf[1024];
+static struct timeval io_tv;
-static gboolean lmtp_write_socket (void *arg);
+static gboolean lmtp_write_socket (void *arg);
void start_lmtp (struct rspamd_worker *worker);
worker_t lmtp_worker = {
- "controller", /* Name */
- NULL, /* Init function */
- start_lmtp, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE /* Killable */
+ "controller", /* Name */
+ NULL, /* Init function */
+ start_lmtp, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE /* Killable */
};
#ifndef HAVE_SA_SIGINFO
static void
sigusr2_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
- struct timeval tv;
+ struct timeval tv;
tv.tv_sec = SOFT_SHUTDOWN_TIME;
tv.tv_usec = 0;
event_del (&worker->sig_ev_usr1);
event_del (&worker->sig_ev_usr2);
event_del (&worker->bind_ev);
- msg_info ("lmtp worker's shutdown is pending in %d sec", SOFT_SHUTDOWN_TIME);
+ msg_info ("lmtp worker's shutdown is pending in %d sec",
+ SOFT_SHUTDOWN_TIME);
event_loopexit (&tv);
return;
}
static void
sigusr1_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
reopen_log (worker->srv->logger);
static void
rcpt_destruct (void *pointer)
{
- struct rspamd_task *task = (struct rspamd_task *)pointer;
+ struct rspamd_task *task = (struct rspamd_task *)pointer;
if (task->rcpt) {
g_list_free (task->rcpt);
static void
free_lmtp_task (struct rspamd_lmtp_proto *lmtp, gboolean is_soft)
{
- GList *part;
- struct mime_part *p;
- struct rspamd_task *task = lmtp->task;
+ GList *part;
+ struct mime_part *p;
+ struct rspamd_task *task = lmtp->task;
if (lmtp) {
debug_task ("free pointer %p", lmtp->task);
/*
* Callback that is called when there is data to read in buffer
*/
-static gboolean
+static gboolean
lmtp_read_socket (f_str_t * in, void *arg)
{
- struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
- struct rspamd_task *task = lmtp->task;
- ssize_t r;
+ struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
+ struct rspamd_task *task = lmtp->task;
+ ssize_t r;
switch (task->state) {
case READ_COMMAND:
}
break;
default:
- debug_task ("invalid state while reading from socket %d", lmtp->task->state);
+ debug_task ("invalid state while reading from socket %d",
+ lmtp->task->state);
break;
}
/*
* Callback for socket writing
*/
-static gboolean
+static gboolean
lmtp_write_socket (void *arg)
{
- struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
- struct rspamd_task *task = lmtp->task;
+ struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
+ struct rspamd_task *task = lmtp->task;
switch (lmtp->task->state) {
case WRITE_REPLY:
return FALSE;
break;
default:
- debug_task ("invalid state while writing to socket %d", lmtp->task->state);
+ debug_task ("invalid state while writing to socket %d",
+ lmtp->task->state);
break;
}
static void
lmtp_err_socket (GError * err, void *arg)
{
- struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
+ struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
msg_info ("abnormally closing connection, error: %s", err->message);
/* Free buffers */
free_lmtp_task (lmtp, FALSE);
static void
accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- union sa_union su;
- struct rspamd_task *new_task;
- struct rspamd_lmtp_proto *lmtp;
- socklen_t addrlen = sizeof (su.ss);
- gint nfd;
-
- if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ union sa_union su;
+ struct rspamd_task *new_task;
+ struct rspamd_lmtp_proto *lmtp;
+ socklen_t addrlen = sizeof (su.ss);
+ gint nfd;
+
+ if ((nfd =
+ accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
new_task->client_addr.s_addr = INADDR_NONE;
}
else if (su.ss.ss_family == AF_INET) {
- msg_info ("accepted connection from %s port %d", inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
- memcpy (&new_task->client_addr, &su.s4.sin_addr, sizeof (struct in_addr));
+ msg_info ("accepted connection from %s port %d",
+ inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
+ memcpy (&new_task->client_addr, &su.s4.sin_addr,
+ sizeof (struct in_addr));
}
new_task->sock = nfd;
new_task->cfg = worker->srv->cfg;
new_task->task_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
/* Add destructor for recipients list (it would be better to use anonymous function here */
- rspamd_mempool_add_destructor (new_task->task_pool, (rspamd_mempool_destruct_t) rcpt_destruct, new_task);
+ rspamd_mempool_add_destructor (new_task->task_pool,
+ (rspamd_mempool_destruct_t) rcpt_destruct, new_task);
new_task->results = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
new_task->ev_base = worker->ctx;
- rspamd_mempool_add_destructor (new_task->task_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, new_task->results);
+ rspamd_mempool_add_destructor (new_task->task_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy, new_task->results);
worker->srv->stat->connections_count++;
lmtp->task = new_task;
lmtp->state = LMTP_READ_LHLO;
/* Set up dispatcher */
- new_task->dispatcher = rspamd_create_dispatcher (new_task->ev_base, nfd, BUFFER_LINE, lmtp_read_socket, lmtp_write_socket, lmtp_err_socket, &io_tv, (void *)lmtp);
+ new_task->dispatcher = rspamd_create_dispatcher (new_task->ev_base,
+ nfd,
+ BUFFER_LINE,
+ lmtp_read_socket,
+ lmtp_write_socket,
+ lmtp_err_socket,
+ &io_tv,
+ (void *)lmtp);
new_task->dispatcher->peer_addr = new_task->client_addr.s_addr;
- if (! rspamd_dispatcher_write (lmtp->task->dispatcher, greetingbuf, strlen (greetingbuf), FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (lmtp->task->dispatcher, greetingbuf,
+ strlen (greetingbuf), FALSE, FALSE)) {
msg_warn ("cannot write greeting");
}
}
void
start_lmtp (struct rspamd_worker *worker)
{
- struct sigaction signals;
- gchar *hostbuf;
- gsize hostmax;
- module_t **mod;
+ struct sigaction signals;
+ gchar *hostbuf;
+ gsize hostmax;
+ module_t **mod;
worker->srv->pid = getpid ();
worker->ctx = event_init ();
sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
/* SIGUSR2 handler */
- signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler, (void *) worker);
+ signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler,
+ (void *) worker);
event_base_set (worker->ctx, &worker->sig_ev_usr2);
signal_add (&worker->sig_ev_usr2, NULL);
/* SIGUSR1 handler */
- signal_set (&worker->sig_ev_usr1, SIGUSR1, sigusr1_handler, (void *) worker);
+ signal_set (&worker->sig_ev_usr1, SIGUSR1, sigusr1_handler,
+ (void *) worker);
event_base_set (worker->ctx, &worker->sig_ev_usr1);
signal_add (&worker->sig_ev_usr1, NULL);
/* Accept event */
- event_set (&worker->bind_ev, worker->cf->listen_sock, EV_READ | EV_PERSIST, accept_socket, (void *)worker);
+ event_set (&worker->bind_ev,
+ worker->cf->listen_sock,
+ EV_READ | EV_PERSIST,
+ accept_socket,
+ (void *)worker);
event_base_set (worker->ctx, &worker->bind_ev);
event_add (&worker->bind_ev, NULL);
mod = &modules[0];
while (*mod) {
(*mod)->module_config_func (worker->srv->cfg);
- mod ++;
+ mod++;
}
/* Fill hostname buf */
hostbuf = alloca (hostmax);
gethostname (hostbuf, hostmax);
hostbuf[hostmax - 1] = '\0';
- rspamd_snprintf (greetingbuf, sizeof (greetingbuf), "%d rspamd version %s LMTP on %s Ready\r\n", LMTP_OK, RVERSION, hostbuf);
+ rspamd_snprintf (greetingbuf,
+ sizeof (greetingbuf),
+ "%d rspamd version %s LMTP on %s Ready\r\n",
+ LMTP_OK,
+ RVERSION,
+ hostbuf);
io_tv.tv_sec = 60000;
io_tv.tv_usec = 0;
exit (EXIT_SUCCESS);
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
-#include "main.h"
#include "cfg_file.h"
-#include "util.h"
+#include "config.h"
#include "lmtp.h"
#include "lmtp_proto.h"
+#include "main.h"
+#include "util.h"
/* Max line size as it is defined in rfc2822 */
#define OUTBUFSIZ 1000
/* LMTP commands */
-static f_str_t lhlo_command = {
+static f_str_t lhlo_command = {
.begin = "LHLO",
.len = sizeof ("LHLO") - 1
};
-static f_str_t mail_command = {
+static f_str_t mail_command = {
.begin = "MAIL FROM:",
.len = sizeof ("MAIL FROM:") - 1
};
-static f_str_t rcpt_command = {
+static f_str_t rcpt_command = {
.begin = "RCPT TO:",
.len = sizeof ("RCPT TO:") - 1
};
-static f_str_t data_command = {
+static f_str_t data_command = {
.begin = "DATA",
.len = sizeof ("DATA") - 1
};
-static f_str_t data_dot = {
+static f_str_t data_dot = {
.begin = ".\r\n",
.len = sizeof (".\r\n") - 1
};
-static const gchar *mail_regexp = "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
-static GRegex *mail_re = NULL;
+static const gchar *mail_regexp =
+ "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
+static GRegex *mail_re = NULL;
/*
- * Extract e-mail from read line
+ * Extract e-mail from read line
* return <> if no valid address detected
*/
-static gchar *
+static gchar *
extract_mail (rspamd_mempool_t * pool, f_str_t * line)
{
- GError *err = NULL;
- gchar *match;
- GMatchInfo *info;
+ GError *err = NULL;
+ gchar *match;
+ GMatchInfo *info;
if (mail_re == NULL) {
/* Compile regexp */
mail_re = g_regex_new (mail_regexp, G_REGEX_RAW, 0, &err);
}
- if (g_regex_match_full (mail_re, line->begin, line->len, 0, 0, &info, NULL) == TRUE) {
+ if (g_regex_match_full (mail_re, line->begin, line->len, 0, 0, &info,
+ NULL) == TRUE) {
match = rspamd_mempool_strdup (pool, g_match_info_fetch (info, 0));
g_match_info_free (info);
}
static gboolean
out_lmtp_reply (struct rspamd_task *task, gint code, gchar *rcode, gchar *msg)
{
- gchar outbuf[OUTBUFSIZ];
- gint r;
+ gchar outbuf[OUTBUFSIZ];
+ gint r;
if (*rcode == '\0') {
r = rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s\r\n", code, msg);
}
else {
- r = rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s %s\r\n", code, rcode, msg);
+ r =
+ rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s %s\r\n", code, rcode,
+ msg);
}
- if (! rspamd_dispatcher_write (task->dispatcher, outbuf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (task->dispatcher, outbuf, r, FALSE, FALSE)) {
return FALSE;
}
return TRUE;
gint
read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
{
- gchar *c, *rcpt;
- f_str_t fstr;
- gint i = 0, l = 0, size;
+ gchar *c, *rcpt;
+ f_str_t fstr;
+ gint i = 0, l = 0, size;
switch (lmtp->state) {
case LMTP_READ_LHLO:
/* Search LHLO line */
if ((i = fstrstri (line, &lhlo_command)) == -1) {
msg_info ("LHLO expected but not found");
- (void)out_lmtp_reply (lmtp->task, LMTP_BAD_CMD, "5.0.0", "Need LHLO here");
+ (void)out_lmtp_reply (lmtp->task,
+ LMTP_BAD_CMD,
+ "5.0.0",
+ "Need LHLO here");
return -1;
}
else {
i++;
c++;
}
- lmtp->task->helo = rspamd_mempool_alloc (lmtp->task->task_pool, line->len - i + 1);
+ lmtp->task->helo = rspamd_mempool_alloc (lmtp->task->task_pool,
+ line->len - i + 1);
/* Strlcpy makes string null terminated by design */
rspamd_strlcpy (lmtp->task->helo, c, line->len - i + 1);
lmtp->state = LMTP_READ_FROM;
- if (! out_lmtp_reply (lmtp->task, LMTP_OK, "", "Ok")) {
+ if (!out_lmtp_reply (lmtp->task, LMTP_OK, "", "Ok")) {
return -1;
}
return 0;
/* Search MAIL FROM: line */
if ((i = fstrstri (line, &mail_command)) == -1) {
msg_info ("MAIL expected but not found");
- (void)out_lmtp_reply (lmtp->task, LMTP_BAD_CMD, "5.0.0", "Need MAIL here");
+ (void)out_lmtp_reply (lmtp->task,
+ LMTP_BAD_CMD,
+ "5.0.0",
+ "Need MAIL here");
return -1;
}
else {
fstr.len = line->len - i;
lmtp->task->from = extract_mail (lmtp->task->task_pool, &fstr);
lmtp->state = LMTP_READ_RCPT;
- if (! out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0", "Sender ok")) {
+ if (!out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0", "Sender ok")) {
return -1;
}
return 0;
/* Search RCPT_TO: line */
if ((i = fstrstri (line, &rcpt_command)) == -1) {
msg_info ("RCPT expected but not found");
- (void)out_lmtp_reply (lmtp->task, LMTP_NO_RCPT, "5.5.4", "Need RCPT here");
+ (void)out_lmtp_reply (lmtp->task,
+ LMTP_NO_RCPT,
+ "5.5.4",
+ "Need RCPT here");
return -1;
}
else {
if (*rcpt == '<' && *(rcpt + 1) == '>') {
/* Invalid or empty rcpt not allowed */
msg_info ("bad recipient");
- (void)out_lmtp_reply (lmtp->task, LMTP_NO_RCPT, "5.5.4", "Bad recipient");
+ (void)out_lmtp_reply (lmtp->task,
+ LMTP_NO_RCPT,
+ "5.5.4",
+ "Bad recipient");
return -1;
}
/* Strlcpy makes string null terminated by design */
lmtp->task->rcpt = g_list_prepend (lmtp->task->rcpt, rcpt);
lmtp->state = LMTP_READ_DATA;
- if (! out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0", "Recipient ok")) {
+ if (!out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0",
+ "Recipient ok")) {
return -1;
}
return 0;
/* Search DATA line */
if ((i = fstrstri (line, &data_command)) == -1) {
msg_info ("DATA expected but not found");
- (void)out_lmtp_reply (lmtp->task, LMTP_BAD_CMD, "5.0.0", "Need DATA here");
+ (void)out_lmtp_reply (lmtp->task,
+ LMTP_BAD_CMD,
+ "5.0.0",
+ "Need DATA here");
return -1;
}
else {
while (g_ascii_isspace (*c++)) {
i++;
}
- rcpt = rspamd_mempool_alloc (lmtp->task->task_pool, line->len - i + 1);
+ rcpt = rspamd_mempool_alloc (lmtp->task->task_pool,
+ line->len - i + 1);
/* Strlcpy makes string null terminated by design */
rspamd_strlcpy (rcpt, c, line->len - i + 1);
lmtp->task->rcpt = g_list_prepend (lmtp->task->rcpt, rcpt);
lmtp->state = LMTP_READ_MESSAGE;
- if (! out_lmtp_reply (lmtp->task, LMTP_DATA, "", "Enter message, ending with \".\" on a line by itself")) {
+ if (!out_lmtp_reply (lmtp->task, LMTP_DATA, "",
+ "Enter message, ending with \".\" on a line by itself")) {
return -1;
}
lmtp->task->msg = fstralloc (lmtp->task->task_pool, BUFSIZ);
/* size *= 2 */
size <<= 1;
}
- lmtp->task->msg = fstrgrow (lmtp->task->task_pool, lmtp->task->msg, size);
+ lmtp->task->msg = fstrgrow (lmtp->task->task_pool,
+ lmtp->task->msg,
+ size);
}
fstrcat (lmtp->task->msg, line);
return 0;
}
break;
case LMTP_READ_DOT:
- /* We have some input after reading dot, close connection as we have no currently support of multiply
+ /* We have some input after reading dot, close connection as we have no currently support of multiply
* messages per session
*/
- if (! out_lmtp_reply (lmtp->task, LMTP_QUIT, "", "Bye")) {
+ if (!out_lmtp_reply (lmtp->task, LMTP_QUIT, "", "Bye")) {
return -1;
}
return 0;
}
struct mta_callback_data {
- struct rspamd_task *task;
- rspamd_io_dispatcher_t *dispatcher;
+ struct rspamd_task *task;
+ rspamd_io_dispatcher_t *dispatcher;
enum {
LMTP_WANT_GREETING,
LMTP_WANT_MAIL,
} state;
};
-static gboolean
+static gboolean
parse_mta_str (f_str_t * in, struct mta_callback_data *cd)
{
- gint r;
- static f_str_t okres1 = {
+ gint r;
+ static f_str_t okres1 = {
.begin = "250 ",
.len = sizeof ("250 ") - 1,
}
, okres2 = {
- .begin = "220 ",.len = sizeof ("220 ") - 1,}
+ .begin = "220 ",.len = sizeof ("220 ") - 1,
+ }
, datares = {
- .begin = "354 ",.len = sizeof ("354 ") - 1,};
+ .begin = "354 ",.len = sizeof ("354 ") - 1,
+ };
switch (cd->state) {
case LMTP_WANT_GREETING:
{
cd->task->state = CLOSING_CONNECTION;
if (is_success) {
- if (! out_lmtp_reply (cd->task, LMTP_OK, "", "Delivery completed")) {
+ if (!out_lmtp_reply (cd->task, LMTP_OK, "", "Delivery completed")) {
return;
}
}
else {
- if (! out_lmtp_reply (cd->task, LMTP_FAILURE, "", "Delivery failure")) {
+ if (!out_lmtp_reply (cd->task, LMTP_FAILURE, "", "Delivery failure")) {
return;
}
}
/*
* Callback that is called when there is data to read in buffer
*/
-static gboolean
+static gboolean
mta_read_socket (f_str_t * in, void *arg)
{
- struct mta_callback_data *cd = (struct mta_callback_data *)arg;
- gchar outbuf[1024], *hostbuf, *c;
- gint hostmax, r;
- GList *cur;
- static f_str_t contres1 = {
+ struct mta_callback_data *cd = (struct mta_callback_data *)arg;
+ gchar outbuf[1024], *hostbuf, *c;
+ gint hostmax, r;
+ GList *cur;
+ static f_str_t contres1 = {
.begin = "250-",
.len = sizeof ("250-") - 1,
}
, contres2 = {
- .begin = "220-",.len = sizeof ("220-") - 1,};
+ .begin = "220-",.len = sizeof ("220-") - 1,
+ };
if (fstrstr (in, &contres1) != -1 || fstrstr (in, &contres2) != -1) {
/* Skip such lines */
gethostname (hostbuf, hostmax);
hostbuf[hostmax - 1] = '\0';
if (cd->task->cfg->deliver_lmtp) {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "LHLO %s" CRLF, hostbuf);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "LHLO %s" CRLF,
+ hostbuf);
}
else {
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "HELO %s" CRLF, hostbuf);
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "HELO %s" CRLF,
+ hostbuf);
}
- if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
+ FALSE)) {
return FALSE;
}
cd->state = LMTP_WANT_MAIL;
close_mta_connection (cd, FALSE);
return FALSE;
}
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: <%s>" CRLF, cd->task->from);
- if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
+ r = rspamd_snprintf (outbuf,
+ sizeof (outbuf),
+ "MAIL FROM: <%s>" CRLF,
+ cd->task->from);
+ if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
+ FALSE)) {
return FALSE;
}
cd->state = LMTP_WANT_RCPT;
cur = g_list_first (cd->task->rcpt);
r = 0;
while (cur) {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "RCPT TO: <%s>" CRLF, (gchar *)cur->data);
+ r += rspamd_snprintf (outbuf + r,
+ sizeof (outbuf) - r,
+ "RCPT TO: <%s>" CRLF,
+ (gchar *)cur->data);
cur = g_list_next (cur);
}
- if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
+ FALSE)) {
return FALSE;
}
cd->state = LMTP_WANT_DATA;
return FALSE;
}
r = rspamd_snprintf (outbuf, sizeof (outbuf), "DATA" CRLF);
- if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
+ FALSE)) {
return FALSE;
}
cd->state = LMTP_WANT_DOT;
}
c = g_mime_object_to_string ((GMimeObject *) cd->task->message);
r = strlen (c);
- if (! rspamd_dispatcher_write (cd->task->dispatcher, c, r, TRUE, TRUE)) {
+ if (!rspamd_dispatcher_write (cd->task->dispatcher, c, r, TRUE, TRUE)) {
return FALSE;
}
- rspamd_mempool_add_destructor (cd->task->task_pool, (rspamd_mempool_destruct_t) g_free, c);
+ rspamd_mempool_add_destructor (cd->task->task_pool,
+ (rspamd_mempool_destruct_t) g_free, c);
r = rspamd_snprintf (outbuf, sizeof (outbuf), CRLF "." CRLF);
- if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
+ if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
+ FALSE)) {
return FALSE;
}
cd->state = LMTP_WANT_CLOSING;
static void
mta_err_socket (GError * err, void *arg)
{
- struct mta_callback_data *cd = (struct mta_callback_data *)arg;
+ struct mta_callback_data *cd = (struct mta_callback_data *)arg;
msg_info ("abnormaly terminating connection with MTA");
close_mta_connection (cd, FALSE);
}
static gint
lmtp_deliver_mta (struct rspamd_task *task)
{
- gint sock;
- struct sockaddr_un *un;
- struct mta_callback_data *cd;
+ gint sock;
+ struct sockaddr_un *un;
+ struct mta_callback_data *cd;
if (task->cfg->deliver_family == AF_UNIX) {
un = alloca (sizeof (struct sockaddr_un));
- sock = make_unix_socket (task->cfg->deliver_host, un, SOCK_STREAM, FALSE, TRUE);
+ sock = make_unix_socket (task->cfg->deliver_host,
+ un,
+ SOCK_STREAM,
+ FALSE,
+ TRUE);
}
else {
- sock = make_universal_socket (task->cfg->deliver_host, task->cfg->deliver_port,
- SOCK_STREAM, TRUE, FALSE, TRUE);
+ sock = make_universal_socket (task->cfg->deliver_host,
+ task->cfg->deliver_port,
+ SOCK_STREAM,
+ TRUE,
+ FALSE,
+ TRUE);
}
if (sock == -1) {
- msg_warn ("cannot create socket for %s, %s", task->cfg->deliver_host, strerror (errno));
+ msg_warn ("cannot create socket for %s, %s",
+ task->cfg->deliver_host,
+ strerror (errno));
}
- cd = rspamd_mempool_alloc (task->task_pool, sizeof (struct mta_callback_data));
+ cd = rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct mta_callback_data));
cd->task = task;
cd->state = LMTP_WANT_GREETING;
- cd->dispatcher = rspamd_create_dispatcher (task->ev_base, sock, BUFFER_LINE, mta_read_socket, NULL, mta_err_socket, NULL, (void *)cd);
+ cd->dispatcher = rspamd_create_dispatcher (task->ev_base,
+ sock,
+ BUFFER_LINE,
+ mta_read_socket,
+ NULL,
+ mta_err_socket,
+ NULL,
+ (void *)cd);
return 0;
}
-static gchar *
+static gchar *
format_lda_args (struct rspamd_task *task)
{
- gchar *res, *c, *r;
- size_t len;
- GList *rcpt;
- gboolean got_args = FALSE;
+ gchar *res, *c, *r;
+ size_t len;
+ GList *rcpt;
+ gboolean got_args = FALSE;
c = task->cfg->deliver_agent_path;
/* Find first arg */
static gint
lmtp_deliver_lda (struct rspamd_task *task)
{
- gchar *args, **argv;
- GMimeStream *stream;
- gint rc, ecode, p[2], argc;
- pid_t cpid, pid;
+ gchar *args, **argv;
+ GMimeStream *stream;
+ gint rc, ecode, p[2], argc;
+ pid_t cpid, pid;
if ((args = format_lda_args (task)) == NULL) {
return -1;
close (p[0]);
stream = g_mime_stream_fs_new (p[1]);
- if (g_mime_object_write_to_stream ((GMimeObject *) task->message, stream) == -1) {
+ if (g_mime_object_write_to_stream ((GMimeObject *) task->message,
+ stream) == -1) {
g_strfreev (argv);
msg_info ("cannot write stream to lda");
return -1;
gint
write_lmtp_reply (struct rspamd_lmtp_proto *lmtp)
{
- gint r;
- struct rspamd_task *task = lmtp->task;
+ gint r;
+ struct rspamd_task *task = lmtp->task;
debug_task ("writing reply to client");
if (lmtp->task->error_code != 0) {
- if (! out_lmtp_reply (lmtp->task, lmtp->task->error_code, "", lmtp->task->last_error)) {
+ if (!out_lmtp_reply (lmtp->task, lmtp->task->error_code, "",
+ lmtp->task->last_error)) {
return -1;
}
}
return -1;
}
else if (r == 0) {
- if (! out_lmtp_reply (lmtp->task, LMTP_OK, "", "Delivery completed")) {
+ if (!out_lmtp_reply (lmtp->task, LMTP_OK, "",
+ "Delivery completed")) {
return -1;
}
}
return 0;
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "buffer.h"
+#include "lua_common.h"
/* Public prototypes */
-struct rspamd_io_dispatcher_s *lua_check_io_dispatcher (lua_State * L);
+struct rspamd_io_dispatcher_s * lua_check_io_dispatcher (lua_State * L);
gint luaopen_io_dispatcher (lua_State * L);
/* Lua bindings */
LUA_FUNCTION_DEF (io_dispatcher, restore);
LUA_FUNCTION_DEF (io_dispatcher, destroy);
-static const struct luaL_reg io_dispatcherlib_m[] = {
+static const struct luaL_reg io_dispatcherlib_m[] = {
LUA_INTERFACE_DEF (io_dispatcher, set_policy),
LUA_INTERFACE_DEF (io_dispatcher, write),
LUA_INTERFACE_DEF (io_dispatcher, pause),
{NULL, NULL}
};
-static const struct luaL_reg io_dispatcherlib_f[] = {
+static const struct luaL_reg io_dispatcherlib_f[] = {
LUA_INTERFACE_DEF (io_dispatcher, create),
{NULL, NULL}
};
gint cbref_err;
};
-struct rspamd_io_dispatcher_s *
+struct rspamd_io_dispatcher_s *
lua_check_io_dispatcher (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{io_dispatcher}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{io_dispatcher}");
luaL_argcheck (L, ud != NULL, 1, "'io_dispatcher' expected");
return ud ? *((struct rspamd_io_dispatcher_s **)ud) : NULL;
}
struct event_base *
lua_check_event_base (lua_State *L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{ev_base}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{ev_base}");
luaL_argcheck (L, ud != NULL, 1, "'ev_base' expected");
return ud ? *((struct event_base **)ud) : NULL;
}
/* Dispatcher callbacks */
-static gboolean
+static gboolean
lua_io_read_cb (f_str_t * in, void *arg)
{
- struct lua_dispatcher_cbdata *cbdata = arg;
- gboolean res;
- rspamd_io_dispatcher_t **pdispatcher;
+ struct lua_dispatcher_cbdata *cbdata = arg;
+ gboolean res;
+ rspamd_io_dispatcher_t **pdispatcher;
/* callback (dispatcher, data) */
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_read);
- pdispatcher = lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
+ pdispatcher =
+ lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
lua_setclass (cbdata->L, "rspamd{io_dispatcher}", -1);
*pdispatcher = cbdata->d;
lua_pushlstring (cbdata->L, in->begin, in->len);
if (lua_pcall (cbdata->L, 2, 1, 0) != 0) {
- msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to session finalizer failed: %s",
+ lua_tostring (cbdata->L, -1));
}
res = lua_toboolean (cbdata->L, -1);
return res;
}
-static gboolean
+static gboolean
lua_io_write_cb (void *arg)
{
- struct lua_dispatcher_cbdata *cbdata = arg;
- gboolean res = FALSE;
- rspamd_io_dispatcher_t **pdispatcher;
+ struct lua_dispatcher_cbdata *cbdata = arg;
+ gboolean res = FALSE;
+ rspamd_io_dispatcher_t **pdispatcher;
if (cbdata->cbref_write) {
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_read);
/* callback (dispatcher) */
- pdispatcher = lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
+ pdispatcher =
+ lua_newuserdata (cbdata->L,
+ sizeof (struct rspamd_io_dispatcher_s *));
lua_setclass (cbdata->L, "rspamd{io_dispatcher}", -1);
*pdispatcher = cbdata->d;
if (lua_pcall (cbdata->L, 1, 1, 0) != 0) {
- msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to session finalizer failed: %s",
+ lua_tostring (cbdata->L, -1));
}
res = lua_toboolean (cbdata->L, -1);
static void
lua_io_err_cb (GError * err, void *arg)
{
- struct lua_dispatcher_cbdata *cbdata = arg;
- rspamd_io_dispatcher_t **pdispatcher;
+ struct lua_dispatcher_cbdata *cbdata = arg;
+ rspamd_io_dispatcher_t **pdispatcher;
/* callback (dispatcher, err) */
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_err);
- pdispatcher = lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
+ pdispatcher =
+ lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
lua_setclass (cbdata->L, "rspamd{io_dispatcher}", -1);
*pdispatcher = cbdata->d;
lua_pushstring (cbdata->L, err->message);
if (lua_pcall (cbdata->L, 2, 0, 0) != 0) {
- msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to session finalizer failed: %s",
+ lua_tostring (cbdata->L, -1));
}
/* Unref callbacks */
static int
lua_io_dispatcher_create (lua_State *L)
{
- struct rspamd_io_dispatcher_s *io_dispatcher, **pdispatcher;
- gint fd;
- struct lua_dispatcher_cbdata *cbdata;
- struct timeval tv = {0, 0};
- double tv_num, tmp;
+ struct rspamd_io_dispatcher_s *io_dispatcher, **pdispatcher;
+ gint fd;
+ struct lua_dispatcher_cbdata *cbdata;
+ struct timeval tv = {0, 0};
+ double tv_num, tmp;
if (lua_gettop (L) >= 5 && lua_isfunction (L, 3) && lua_isfunction (L, 5)) {
cbdata = g_slice_alloc0 (sizeof (struct lua_dispatcher_cbdata));
tv_num = lua_tonumber (L, 6);
tv.tv_sec = trunc (tv_num);
tv.tv_usec = modf (tv_num, &tmp) * 1000.;
- io_dispatcher = rspamd_create_dispatcher (cbdata->base, fd, BUFFER_LINE, lua_io_read_cb, lua_io_write_cb, lua_io_err_cb, &tv, cbdata);
+ io_dispatcher = rspamd_create_dispatcher (cbdata->base,
+ fd,
+ BUFFER_LINE,
+ lua_io_read_cb,
+ lua_io_write_cb,
+ lua_io_err_cb,
+ &tv,
+ cbdata);
}
else {
- io_dispatcher = rspamd_create_dispatcher (cbdata->base, fd, BUFFER_LINE, lua_io_read_cb, lua_io_write_cb, lua_io_err_cb, NULL, cbdata);
+ io_dispatcher = rspamd_create_dispatcher (cbdata->base,
+ fd,
+ BUFFER_LINE,
+ lua_io_read_cb,
+ lua_io_write_cb,
+ lua_io_err_cb,
+ NULL,
+ cbdata);
}
cbdata->d = io_dispatcher;
/* Push result */
- pdispatcher = lua_newuserdata (L, sizeof (struct rspamd_io_dispatcher_s *));
+ pdispatcher =
+ lua_newuserdata (L, sizeof (struct rspamd_io_dispatcher_s *));
lua_setclass (L, "rspamd{io_dispatcher}", -1);
*pdispatcher = io_dispatcher;
}
else {
- msg_err ("invalid number of arguments to io_dispatcher.create: %d", lua_gettop (L));
+ msg_err ("invalid number of arguments to io_dispatcher.create: %d",
+ lua_gettop (L));
lua_pushnil (L);
}
static int
lua_io_dispatcher_set_policy (lua_State *L)
{
- struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
- gint policy, limit = -1;
+ struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+ gint policy, limit = -1;
if (io_dispatcher) {
policy = lua_tonumber (L, 2);
static int
lua_io_dispatcher_write (lua_State *L)
{
- struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
- gboolean delayed = FALSE, res;
- const gchar *data;
- size_t len;
+ struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+ gboolean delayed = FALSE, res;
+ const gchar *data;
+ size_t len;
if (io_dispatcher) {
if (lua_gettop (L) < 2) {
- msg_err ("invalid number of arguments to io_dispatcher.create: %d", lua_gettop (L));
+ msg_err ("invalid number of arguments to io_dispatcher.create: %d",
+ lua_gettop (L));
lua_pushboolean (L, FALSE);
}
else {
if (lua_gettop (L) > 2) {
delayed = lua_toboolean (L, 3);
}
- res = rspamd_dispatcher_write (io_dispatcher, (void *)data, len, delayed, FALSE);
+ res = rspamd_dispatcher_write (io_dispatcher,
+ (void *)data,
+ len,
+ delayed,
+ FALSE);
lua_pushboolean (L, res);
}
}
static int
lua_io_dispatcher_pause (lua_State *L)
{
- struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+ struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
if (io_dispatcher) {
rspamd_dispatcher_pause (io_dispatcher);
static int
lua_io_dispatcher_restore (lua_State *L)
{
- struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+ struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
if (io_dispatcher) {
rspamd_dispatcher_restore (io_dispatcher);
static int
lua_io_dispatcher_destroy (lua_State *L)
{
- struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+ struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
if (io_dispatcher) {
rspamd_remove_dispatcher (io_dispatcher);
lua_pushstring (L, "rspamd{io_dispatcher}");
lua_rawset (L, -3);
- luaL_register (L, NULL, io_dispatcherlib_m);
+ luaL_register (L, NULL, io_dispatcherlib_m);
luaL_register (L, "rspamd_io_dispatcher", io_dispatcherlib_f);
- lua_pop(L, 1); /* remove metatable from stack */
+ lua_pop (L, 1); /* remove metatable from stack */
/* Simple event class */
lua_newclass (L, "rspamd{ev_base}", null_reg);
luaL_register (L, "rspamd_ev_base", null_reg);
- lua_pop(L, 1); /* remove metatable from stack */
+ lua_pop (L, 1); /* remove metatable from stack */
/* Set buffer types globals */
lua_pushnumber (L, BUFFER_LINE);
lua_setglobal (L, "IO_BUFFER_CHARACTER");
lua_pushnumber (L, BUFFER_ANY);
lua_setglobal (L, "IO_BUFFER_ANY");
- return 1;
+ return 1;
}
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "cdb/cdb.h"
+#include "lua_common.h"
#define CDB_REFRESH_TIME 60
LUA_FUNCTION_DEF (cdb, get_name);
LUA_FUNCTION_DEF (cdb, destroy);
-static const struct luaL_reg cdblib_m[] = {
+static const struct luaL_reg cdblib_m[] = {
LUA_INTERFACE_DEF (cdb, lookup),
LUA_INTERFACE_DEF (cdb, get_name),
{"__tostring", lua_class_tostring},
{"__gc", lua_cdb_destroy},
{NULL, NULL}
};
-static const struct luaL_reg cdblib_f[] = {
+static const struct luaL_reg cdblib_f[] = {
LUA_INTERFACE_DEF (cdb, create),
{NULL, NULL}
};
-static struct cdb *
+static struct cdb *
lua_check_cdb (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{cdb}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{cdb}");
luaL_argcheck (L, ud != NULL, 1, "'cdb' expected");
return ud ? *((struct cdb **)ud) : NULL;
static gint
lua_cdb_create (lua_State *L)
{
- struct cdb *cdb, **pcdb;
- const gchar *filename;
- gint fd;
+ struct cdb *cdb, **pcdb;
+ const gchar *filename;
+ gint fd;
filename = luaL_checkstring (L, 1);
/* If file begins with cdb://, just skip it */
lua_pushnil (L);
}
else {
- pcdb = lua_newuserdata (L, sizeof (struct cdb*));
+ pcdb = lua_newuserdata (L, sizeof (struct cdb *));
lua_setclass (L, "rspamd{cdb}", -1);
*pcdb = cdb;
}
static gint
lua_cdb_get_name (lua_State *L)
{
- struct cdb *cdb = lua_check_cdb (L);
+ struct cdb *cdb = lua_check_cdb (L);
lua_pushstring (L, cdb->filename);
return 1;
static gint
lua_cdb_lookup (lua_State *L)
{
- struct cdb *cdb = lua_check_cdb (L);
- const gchar *what;
- gchar *value;
- gsize vlen;
- gint64 vpos;
+ struct cdb *cdb = lua_check_cdb (L);
+ const gchar *what;
+ gchar *value;
+ gsize vlen;
+ gint64 vpos;
/*
* XXX: this code is placed here because event_loop is called inside workers, so start
static gint
lua_cdb_destroy (lua_State *L)
{
- struct cdb *cdb = lua_check_cdb (L);
+ struct cdb *cdb = lua_check_cdb (L);
if (cdb) {
cdb_free (cdb);
lua_pushstring (L, "rspamd{cdb}");
lua_rawset (L, -3);
- luaL_register (L, NULL, cdblib_m);
+ luaL_register (L, NULL, cdblib_m);
luaL_register (L, "cdb", cdblib_f);
lua_pop (L, 1); /* remove metatable from stack */
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "expressions.h"
+#include "lua_common.h"
#include "symbols_cache.h"
#ifdef HAVE_SYS_UTSNAME_H
#include <sys/utsname.h>
#endif
-/*
- * This is implementation of lua routines to handle config file params
+/*
+ * This is implementation of lua routines to handle config file params
*/
/* Process a single item in 'metrics' table */
static void
lua_process_metric (lua_State *L, const gchar *name, struct rspamd_config *cfg)
{
- GList *metric_list;
- gchar *symbol, *old_desc;
- const gchar *desc;
- struct metric *metric;
- gdouble *score, *old_score;
+ GList *metric_list;
+ gchar *symbol, *old_desc;
+ const gchar *desc;
+ struct metric *metric;
+ gdouble *score, *old_score;
/* Get module opt structure */
if ((metric = g_hash_table_lookup (cfg->metrics, name)) == NULL) {
}
/* Now iterate throught module table */
- for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
+ for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
/* key - -2, value - -1 */
- symbol = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, -2));
+ symbol =
+ rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, -2));
if (symbol != NULL) {
if (lua_istable (L, -1)) {
/* We got a table, so extract individual attributes */
lua_pushstring (L, "weight");
lua_gettable (L, -2);
if (lua_isnumber (L, -1)) {
- score = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (double));
+ score =
+ rspamd_mempool_alloc (cfg->cfg_pool, sizeof (double));
*score = lua_tonumber (L, -1);
}
else {
lua_gettable (L, -2);
if (lua_isstring (L, -1)) {
desc = lua_tostring (L, -1);
- old_desc = g_hash_table_lookup (metric->descriptions, symbol);
+ old_desc =
+ g_hash_table_lookup (metric->descriptions, symbol);
if (old_desc) {
- msg_info ("replacing description for symbol %s", symbol);
+ msg_info ("replacing description for symbol %s",
+ symbol);
g_hash_table_replace (metric->descriptions,
- symbol, rspamd_mempool_strdup (cfg->cfg_pool, desc));
+ symbol,
+ rspamd_mempool_strdup (cfg->cfg_pool, desc));
}
else {
g_hash_table_insert (metric->descriptions,
- symbol, rspamd_mempool_strdup (cfg->cfg_pool, desc));
+ symbol,
+ rspamd_mempool_strdup (cfg->cfg_pool, desc));
}
}
lua_pop (L, 1);
continue;
}
/* Insert symbol */
- if ((old_score = g_hash_table_lookup (metric->symbols, symbol)) != NULL) {
- msg_info ("replacing weight for symbol %s: %.2f -> %.2f", symbol, *old_score, *score);
+ if ((old_score =
+ g_hash_table_lookup (metric->symbols, symbol)) != NULL) {
+ msg_info ("replacing weight for symbol %s: %.2f -> %.2f",
+ symbol,
+ *old_score,
+ *score);
g_hash_table_replace (metric->symbols, symbol, score);
}
else {
g_hash_table_insert (metric->symbols, symbol, score);
}
- if ((metric_list = g_hash_table_lookup (cfg->metrics_symbols, symbol)) == NULL) {
+ if ((metric_list =
+ g_hash_table_lookup (cfg->metrics_symbols, symbol)) == NULL) {
metric_list = g_list_prepend (NULL, metric);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_list_free, metric_list);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_list_free, metric_list);
g_hash_table_insert (cfg->metrics_symbols, symbol, metric_list);
}
else {
void
lua_post_load_config (struct rspamd_config *cfg)
{
- lua_State *L = cfg->lua_state;
- const gchar *name, *val;
- gchar *sym;
- struct expression *expr, *old_expr;
- ucl_object_t *obj;
- gsize keylen;
+ lua_State *L = cfg->lua_state;
+ const gchar *name, *val;
+ gchar *sym;
+ struct expression *expr, *old_expr;
+ ucl_object_t *obj;
+ gsize keylen;
/* First check all module options that may be overriden in 'config' global */
lua_getglobal (L, "config");
if (lua_istable (L, -1)) {
/* Iterate */
- for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
+ for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
/* 'key' is at index -2 and 'value' is at index -1 */
/* Key must be a string and value must be a table */
name = luaL_checklstring (L, -2, &keylen);
if (name != NULL && lua_istable (L, -1)) {
obj = ucl_object_lua_import (L, lua_gettop (L));
if (obj != NULL) {
- ucl_object_insert_key_merged (cfg->rcl_obj, obj, name, keylen, true);
+ ucl_object_insert_key_merged (cfg->rcl_obj,
+ obj,
+ name,
+ keylen,
+ true);
}
}
}
if (lua_istable (L, -1)) {
/* Iterate */
- for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
+ for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
/* 'key' is at index -2 and 'value' is at index -1 */
/* Key must be a string and value must be a table */
name = luaL_checkstring (L, -2);
if (lua_istable (L, -1)) {
/* Iterate */
- for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
+ for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
/* 'key' is at index -2 and 'value' is at index -1 */
/* Key must be a string and value must be a table */
name = luaL_checkstring (L, -2);
if (name != NULL && lua_isstring (L, -1)) {
val = lua_tostring (L, -1);
- sym = rspamd_mempool_strdup(cfg->cfg_pool, name);
- if ((expr = parse_expression (cfg->cfg_pool, rspamd_mempool_strdup(cfg->cfg_pool, val))) == NULL) {
+ sym = rspamd_mempool_strdup (cfg->cfg_pool, name);
+ if ((expr =
+ parse_expression (cfg->cfg_pool,
+ rspamd_mempool_strdup (cfg->cfg_pool, val))) == NULL) {
msg_err ("cannot parse composite expression: %s", val);
continue;
}
/* Now check hash table for this composite */
- if ((old_expr = g_hash_table_lookup (cfg->composite_symbols, name)) != NULL) {
+ if ((old_expr =
+ g_hash_table_lookup (cfg->composite_symbols,
+ name)) != NULL) {
msg_info ("replacing composite symbol %s", name);
g_hash_table_replace (cfg->composite_symbols, sym, expr);
}
/* Handle lua dynamic config param */
gboolean
-lua_handle_param (struct rspamd_task *task, gchar *mname, gchar *optname, enum lua_var_type expected_type, gpointer *res)
+lua_handle_param (struct rspamd_task *task,
+ gchar *mname,
+ gchar *optname,
+ enum lua_var_type expected_type,
+ gpointer *res)
{
/* xxx: Adopt this for rcl */
-
+
/* Option not found */
*res = NULL;
return FALSE;
gboolean
lua_check_condition (struct rspamd_config *cfg, const gchar *condition)
{
- lua_State *L = cfg->lua_state;
- gchar *hostbuf, *condbuf;
- gsize hostlen;
- gboolean res;
+ lua_State *L = cfg->lua_state;
+ gchar *hostbuf, *condbuf;
+ gsize hostlen;
+ gboolean res;
#ifdef HAVE_SYS_UTSNAME_H
- struct utsname uts;
+ struct utsname uts;
#endif
/* Set some globals for condition */
/* Rspamd paths */
lua_newtable (L);
- lua_set_table_index (L, "confdir", RSPAMD_CONFDIR);
- lua_set_table_index (L, "rundir", RSPAMD_RUNDIR);
- lua_set_table_index (L, "dbdir", RSPAMD_DBDIR);
- lua_set_table_index (L, "logdir", RSPAMD_LOGDIR);
+ lua_set_table_index (L, "confdir", RSPAMD_CONFDIR);
+ lua_set_table_index (L, "rundir", RSPAMD_RUNDIR);
+ lua_set_table_index (L, "dbdir", RSPAMD_DBDIR);
+ lua_set_table_index (L, "logdir", RSPAMD_LOGDIR);
lua_set_table_index (L, "pluginsdir", RSPAMD_PLUGINSDIR);
- lua_set_table_index (L, "prefix", RSPAMD_PREFIX);
+ lua_set_table_index (L, "prefix", RSPAMD_PREFIX);
lua_setglobal (L, "rspamd_paths");
/* Make fake string */
}
/* Get global variable res to get result */
lua_getglobal (L, FAKE_RES_VAR);
- if (! lua_isboolean (L, -1)) {
- msg_err ("bad string evaluated: %s, type: %s", condbuf, lua_typename (L, lua_type (L, -1)));
+ if (!lua_isboolean (L, -1)) {
+ msg_err ("bad string evaluated: %s, type: %s", condbuf,
+ lua_typename (L, lua_type (L, -1)));
g_free (condbuf);
- return FALSE;
+ return FALSE;
}
res = lua_toboolean (L, -1);
*/
-#include "lua_common.h"
#include "cfg_file.h"
#include "classifiers/classifiers.h"
+#include "lua_common.h"
/* Classifier methods */
LUA_FUNCTION_DEF (classifier, register_pre_callback);
LUA_FUNCTION_DEF (classifier, get_statfiles);
LUA_FUNCTION_DEF (classifier, get_statfile_by_label);
-static const struct luaL_reg classifierlib_m[] = {
+static const struct luaL_reg classifierlib_m[] = {
LUA_INTERFACE_DEF (classifier, register_pre_callback),
LUA_INTERFACE_DEF (classifier, register_post_callback),
LUA_INTERFACE_DEF (classifier, get_statfiles),
LUA_FUNCTION_DEF (statfile, is_spam);
LUA_FUNCTION_DEF (statfile, get_param);
-static const struct luaL_reg statfilelib_m[] = {
+static const struct luaL_reg statfilelib_m[] = {
LUA_INTERFACE_DEF (statfile, get_symbol),
LUA_INTERFACE_DEF (statfile, get_label),
LUA_INTERFACE_DEF (statfile, get_path),
const gchar *name;
};
-static struct rspamd_statfile_config* lua_check_statfile (lua_State * L);
+static struct rspamd_statfile_config * lua_check_statfile (lua_State * L);
/* Classifier implementation */
-static struct rspamd_classifier_config *
+static struct rspamd_classifier_config *
lua_check_classifier (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{classifier}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{classifier}");
luaL_argcheck (L, ud != NULL, 1, "'classifier' expected");
return ud ? *((struct rspamd_classifier_config **)ud) : NULL;
}
static GList *
-call_classifier_pre_callback (struct rspamd_classifier_config *ccf, struct rspamd_task *task,
- lua_State *L, gboolean is_learn, gboolean is_spam)
+call_classifier_pre_callback (struct rspamd_classifier_config *ccf,
+ struct rspamd_task *task,
+ lua_State *L,
+ gboolean is_learn,
+ gboolean is_spam)
{
- struct rspamd_classifier_config **pccf;
- struct rspamd_task **ptask;
- struct rspamd_statfile_config **pst;
- GList *res = NULL;
+ struct rspamd_classifier_config **pccf;
+ struct rspamd_task **ptask;
+ struct rspamd_statfile_config **pst;
+ GList *res = NULL;
pccf = lua_newuserdata (L, sizeof (struct rspamd_classifier_config *));
lua_setclass (L, "rspamd{classifier}", -1);
lua_pushboolean (L, is_spam);
if (lua_pcall (L, 4, 1, 0) != 0) {
- msg_warn ("error running pre classifier callback %s", lua_tostring (L, -1));
+ msg_warn ("error running pre classifier callback %s",
+ lua_tostring (L, -1));
}
else {
if (lua_istable (L, -1)) {
lua_pushnil (L);
- while(lua_next (L, -2)) {
+ while (lua_next (L, -2)) {
pst = luaL_checkudata (L, -1, "rspamd{statfile}");
if (pst) {
res = g_list_prepend (res, *pst);
/* Return list of statfiles that should be checked for this message */
GList *
-call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task,
- gboolean is_learn, gboolean is_spam, lua_State *L)
+call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
+ struct rspamd_task *task,
+ gboolean is_learn,
+ gboolean is_spam,
+ lua_State *L)
{
- GList *res = NULL, *cur;
+ GList *res = NULL, *cur;
struct classifier_callback_data *cd;
cd = cur->data;
lua_getglobal (L, cd->name);
- res = g_list_concat (res, call_classifier_pre_callback (ccf, task, L, is_learn, is_spam));
+ res =
+ g_list_concat (res,
+ call_classifier_pre_callback (ccf, task, L, is_learn, is_spam));
cur = g_list_next (cur);
}
lua_gettable (L, -2);
/* Function is now on top */
if (lua_isfunction (L, -1)) {
- res = call_classifier_pre_callback (ccf, task, L, is_learn, is_spam);
+ res = call_classifier_pre_callback (ccf,
+ task,
+ L,
+ is_learn,
+ is_spam);
}
lua_pop (L, 1);
}
/* Return result mark for statfile */
double
-call_classifier_post_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task, double in, lua_State *L)
+call_classifier_post_callbacks (struct rspamd_classifier_config *ccf,
+ struct rspamd_task *task,
+ double in,
+ lua_State *L)
{
struct classifier_callback_data *cd;
- struct rspamd_classifier_config **pccf;
- struct rspamd_task **ptask;
- double out = in;
- GList *cur;
+ struct rspamd_classifier_config **pccf;
+ struct rspamd_task **ptask;
+ double out = in;
+ GList *cur;
/* Go throught all callbacks and call them, appending results to list */
cur = g_list_first (ccf->pre_callbacks);
lua_pushnumber (L, out);
if (lua_pcall (L, 3, 1, 0) != 0) {
- msg_warn ("error running function %s: %s", cd->name, lua_tostring (L, -1));
+ msg_warn ("error running function %s: %s", cd->name,
+ lua_tostring (L, -1));
}
else {
if (lua_isnumber (L, 1)) {
static gint
lua_classifier_register_pre_callback (lua_State *L)
{
- struct rspamd_classifier_config *ccf = lua_check_classifier (L);
+ struct rspamd_classifier_config *ccf = lua_check_classifier (L);
struct classifier_callback_data *cd;
- const gchar *name;
+ const gchar *name;
if (ccf) {
name = luaL_checkstring (L, 2);
static gint
lua_classifier_register_post_callback (lua_State *L)
{
- struct rspamd_classifier_config *ccf = lua_check_classifier (L);
+ struct rspamd_classifier_config *ccf = lua_check_classifier (L);
struct classifier_callback_data *cd;
- const gchar *name;
+ const gchar *name;
if (ccf) {
name = luaL_checkstring (L, 2);
static gint
lua_classifier_get_statfiles (lua_State *L)
{
- struct rspamd_classifier_config *ccf = lua_check_classifier (L);
- GList *cur;
- struct rspamd_statfile_config *st, **pst;
- gint i;
+ struct rspamd_classifier_config *ccf = lua_check_classifier (L);
+ GList *cur;
+ struct rspamd_statfile_config *st, **pst;
+ gint i;
if (ccf) {
lua_newtable (L);
static gint
lua_classifier_get_statfile_by_label (lua_State *L)
{
- struct rspamd_classifier_config *ccf = lua_check_classifier (L);
- struct rspamd_statfile_config *st, **pst;
- const gchar *label;
- GList *cur;
- gint i;
+ struct rspamd_classifier_config *ccf = lua_check_classifier (L);
+ struct rspamd_statfile_config *st, **pst;
+ const gchar *label;
+ GList *cur;
+ gint i;
label = luaL_checkstring (L, 2);
if (ccf && label) {
i = 1;
while (cur) {
st = cur->data;
- pst = lua_newuserdata (L, sizeof (struct rspamd_statfile_config *));
+ pst =
+ lua_newuserdata (L,
+ sizeof (struct rspamd_statfile_config *));
lua_setclass (L, "rspamd{statfile}", -1);
*pst = st;
lua_rawseti (L, -2, i++);
static gint
lua_statfile_get_symbol (lua_State *L)
{
- struct rspamd_statfile_config *st = lua_check_statfile (L);
+ struct rspamd_statfile_config *st = lua_check_statfile (L);
if (st != NULL) {
lua_pushstring (L, st->symbol);
static gint
lua_statfile_get_label (lua_State *L)
{
- struct rspamd_statfile_config *st = lua_check_statfile (L);
+ struct rspamd_statfile_config *st = lua_check_statfile (L);
if (st != NULL && st->label != NULL) {
lua_pushstring (L, st->label);
static gint
lua_statfile_get_path (lua_State *L)
{
- struct rspamd_statfile_config *st = lua_check_statfile (L);
+ struct rspamd_statfile_config *st = lua_check_statfile (L);
if (st != NULL) {
lua_pushstring (L, st->path);
static gint
lua_statfile_get_size (lua_State *L)
{
- struct rspamd_statfile_config *st = lua_check_statfile (L);
+ struct rspamd_statfile_config *st = lua_check_statfile (L);
if (st != NULL) {
lua_pushinteger (L, st->size);
static gint
lua_statfile_is_spam (lua_State *L)
{
- struct rspamd_statfile_config *st = lua_check_statfile (L);
+ struct rspamd_statfile_config *st = lua_check_statfile (L);
if (st != NULL) {
lua_pushboolean (L, st->is_spam);
static gint
lua_statfile_get_param (lua_State *L)
{
- struct rspamd_statfile_config *st = lua_check_statfile (L);
- const gchar *param;
- const ucl_object_t *value;
+ struct rspamd_statfile_config *st = lua_check_statfile (L);
+ const gchar *param;
+ const ucl_object_t *value;
param = luaL_checkstring (L, 2);
return 1;
}
-static struct rspamd_statfile_config *
+static struct rspamd_statfile_config *
lua_check_statfile (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{statfile}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{statfile}");
luaL_argcheck (L, ud != NULL, 1, "'statfile' expected");
return ud ? *((struct rspamd_statfile_config **)ud) : NULL;
}
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "expressions.h"
+#include "lua_common.h"
/* Lua module init function */
#define MODULE_INIT_FUNC "module_init"
-const luaL_reg null_reg[] = {
+const luaL_reg null_reg[] = {
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
LUA_FUNCTION_DEF (logger, info);
LUA_FUNCTION_DEF (logger, debug);
-static const struct luaL_reg loggerlib_f[] = {
+static const struct luaL_reg loggerlib_f[] = {
LUA_INTERFACE_DEF (logger, err),
LUA_INTERFACE_DEF (logger, warn),
LUA_INTERFACE_DEF (logger, info),
* @param func table of class methods
*/
void
-lua_newclass (lua_State * L, const gchar *classname, const struct luaL_reg *methods)
+lua_newclass (lua_State * L,
+ const gchar *classname,
+ const struct luaL_reg *methods)
{
- luaL_newmetatable (L, classname); /* mt */
+ luaL_newmetatable (L, classname); /* mt */
lua_pushstring (L, "__index");
- lua_pushvalue (L, -2); /* pushes the metatable */
- lua_settable (L, -3); /* metatable.__index = metatable */
+ lua_pushvalue (L, -2); /* pushes the metatable */
+ lua_settable (L, -3); /* metatable.__index = metatable */
- lua_pushstring (L, "class"); /* mt,"__index",it,"class" */
- lua_pushstring (L, classname); /* mt,"__index",it,"class",classname */
- lua_rawset (L, -3); /* mt,"__index",it */
+ lua_pushstring (L, "class"); /* mt,"__index",it,"class" */
+ lua_pushstring (L, classname); /* mt,"__index",it,"class",classname */
+ lua_rawset (L, -3); /* mt,"__index",it */
luaL_register (L, NULL, methods);
}
* Create and register new class with static methods and store metatable on top of the stack
*/
void
-lua_newclass_full (lua_State *L, const gchar *classname, const gchar *static_name, const struct luaL_reg *methods, const struct luaL_reg *func)
+lua_newclass_full (lua_State *L,
+ const gchar *classname,
+ const gchar *static_name,
+ const struct luaL_reg *methods,
+ const struct luaL_reg *func)
{
lua_newclass (L, classname, methods);
luaL_register (L, static_name, func);
gint
lua_class_tostring (lua_State * L)
{
- gchar buf[32];
+ gchar buf[32];
if (!lua_getmetatable (L, 1)) {
goto error;
return 1;
- error:
+error:
lua_pushstring (L, "invalid object passed to 'lua_common.c:__tostring'");
lua_error (L);
return 1;
static void
lua_common_log (GLogLevelFlags level, lua_State *L, const gchar *msg)
{
- lua_Debug d;
- gchar func_buf[128], *p;
+ lua_Debug d;
+ gchar func_buf[128], *p;
if (lua_getstack (L, 1, &d) == 1) {
- (void)lua_getinfo(L, "Sl", &d);
+ (void)lua_getinfo (L, "Sl", &d);
if ((p = strrchr (d.short_src, '/')) == NULL) {
p = d.short_src;
}
else {
- p ++;
+ p++;
}
- rspamd_snprintf (func_buf, sizeof (func_buf), "%s:%d", p, d.currentline);
+ rspamd_snprintf (func_buf, sizeof (func_buf), "%s:%d", p,
+ d.currentline);
if (level == G_LOG_LEVEL_DEBUG) {
- rspamd_conditional_debug (rspamd_main->logger, NULL, func_buf, "%s", msg);
+ rspamd_conditional_debug (rspamd_main->logger,
+ NULL,
+ func_buf,
+ "%s",
+ msg);
}
else {
- rspamd_common_log_function (rspamd_main->logger, level, func_buf, "%s", msg);
+ rspamd_common_log_function (rspamd_main->logger,
+ level,
+ func_buf,
+ "%s",
+ msg);
}
}
else {
if (level == G_LOG_LEVEL_DEBUG) {
- rspamd_conditional_debug (rspamd_main->logger, NULL, __FUNCTION__, "%s", msg);
+ rspamd_conditional_debug (rspamd_main->logger,
+ NULL,
+ __FUNCTION__,
+ "%s",
+ msg);
}
else {
- rspamd_common_log_function (rspamd_main->logger, level, __FUNCTION__, "%s", msg);
+ rspamd_common_log_function (rspamd_main->logger,
+ level,
+ __FUNCTION__,
+ "%s",
+ msg);
}
}
}
static gint
lua_logger_err (lua_State * L)
{
- const gchar *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 1);
lua_common_log (G_LOG_LEVEL_CRITICAL, L, msg);
return 1;
static gint
lua_logger_warn (lua_State * L)
{
- const gchar *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 1);
lua_common_log (G_LOG_LEVEL_WARNING, L, msg);
return 1;
static gint
lua_logger_info (lua_State * L)
{
- const gchar *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 1);
lua_common_log (G_LOG_LEVEL_INFO, L, msg);
return 1;
static gint
lua_logger_debug (lua_State * L)
{
- const gchar *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 1);
lua_common_log (G_LOG_LEVEL_DEBUG, L, msg);
return 1;
static void
lua_add_actions_global (lua_State *L)
{
- gint i;
+ gint i;
lua_newtable (L);
- for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i ++) {
+ for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
lua_pushstring (L, str_action_metric (i));
lua_pushinteger (L, i);
lua_settable (L, -3);
lua_State *
init_lua (struct rspamd_config *cfg)
{
- lua_State *L;
+ lua_State *L;
L = luaL_newstate ();
luaL_openlibs (L);
/**
* Initialize new locked lua_State structure
*/
-struct lua_locked_state*
+struct lua_locked_state *
init_lua_locked (struct rspamd_config *cfg)
{
- struct lua_locked_state *new;
+ struct lua_locked_state *new;
new = g_slice_alloc (sizeof (struct lua_locked_state));
new->L = init_lua (cfg);
gboolean
init_lua_filters (struct rspamd_config *cfg)
{
- struct rspamd_config **pcfg;
- GList *cur, *tmp;
- struct script_module *module;
- struct rspamd_statfile_config *st;
- lua_State *L = cfg->lua_state;
+ struct rspamd_config **pcfg;
+ GList *cur, *tmp;
+ struct script_module *module;
+ struct rspamd_statfile_config *st;
+ lua_State *L = cfg->lua_state;
cur = g_list_first (cfg->script_modules);
while (cur) {
module = cur->data;
if (module->path) {
if (luaL_loadfile (L, module->path) != 0) {
- msg_info ("load of %s failed: %s", module->path, lua_tostring (L, -1));
+ msg_info ("load of %s failed: %s", module->path,
+ lua_tostring (L, -1));
cur = g_list_next (cur);
return FALSE;
}
/* do the call (0 arguments, N result) */
if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) {
- msg_info ("init of %s failed: %s", module->path, lua_tostring (L, -1));
+ msg_info ("init of %s failed: %s", module->path,
+ lua_tostring (L, -1));
return FALSE;
}
if (lua_gettop (L) != 0) {
if (lua_tonumber (L, -1) == -1) {
- msg_info ("%s returned -1 that indicates configuration error", module->path);
+ msg_info (
+ "%s returned -1 that indicates configuration error",
+ module->path);
return FALSE;
}
lua_pop (L, lua_gettop (L));
}
cur = g_list_next (cur);
}
- /* Init statfiles normalizers */
- cur = g_list_first (cfg->statfiles);
- while (cur) {
- st = cur->data;
- if (st->normalizer == lua_normalizer_func) {
- tmp = st->normalizer_data;
- if (tmp && (tmp = g_list_next (tmp))) {
- if (tmp->data) {
- /* Code must be loaded from data */
- if (luaL_loadstring (L, tmp->data) != 0) {
- msg_info ("cannot load normalizer code %s", tmp->data);
- return FALSE;
- }
- }
- }
- }
- cur = g_list_next (cur);
- }
+ /* Init statfiles normalizers */
+ cur = g_list_first (cfg->statfiles);
+ while (cur) {
+ st = cur->data;
+ if (st->normalizer == lua_normalizer_func) {
+ tmp = st->normalizer_data;
+ if (tmp && (tmp = g_list_next (tmp))) {
+ if (tmp->data) {
+ /* Code must be loaded from data */
+ if (luaL_loadstring (L, tmp->data) != 0) {
+ msg_info ("cannot load normalizer code %s", tmp->data);
+ return FALSE;
+ }
+ }
+ }
+ }
+ cur = g_list_next (cur);
+ }
/* Assign state */
cfg->lua_state = L;
gint
lua_call_filter (const gchar *function, struct rspamd_task *task)
{
- gint result;
- struct rspamd_task **ptask;
- lua_State *L = task->cfg->lua_state;
+ gint result;
+ struct rspamd_task **ptask;
+ lua_State *L = task->cfg->lua_state;
lua_getglobal (L, function);
ptask = lua_newuserdata (L, sizeof (struct rspamd_task *));
msg_info ("function %s must return a number", function);
}
result = lua_tonumber (L, -1);
- lua_pop (L, 1); /* pop returned value */
+ lua_pop (L, 1); /* pop returned value */
return result;
}
gint
-lua_call_chain_filter (const gchar *function, struct rspamd_task *task, gint *marks, guint number)
+lua_call_chain_filter (const gchar *function,
+ struct rspamd_task *task,
+ gint *marks,
+ guint number)
{
- gint result;
- guint i;
- lua_State *L = task->cfg->lua_state;
+ gint result;
+ guint i;
+ lua_State *L = task->cfg->lua_state;
lua_getglobal (L, function);
msg_info ("function %s must return a number", function);
}
result = lua_tonumber (L, -1);
- lua_pop (L, 1); /* pop returned value */
+ lua_pop (L, 1); /* pop returned value */
return result;
}
/* Call custom lua function in rspamd expression */
-gboolean
+gboolean
lua_call_expression_func (gpointer lua_data,
- struct rspamd_task *task, GList *args, gboolean *res)
+ struct rspamd_task *task, GList *args, gboolean *res)
{
- lua_State *L = task->cfg->lua_state;
- struct rspamd_task **ptask;
- GList *cur;
- struct expression_argument *arg;
- int nargs = 1, pop = 0;
+ lua_State *L = task->cfg->lua_state;
+ struct rspamd_task **ptask;
+ GList *cur;
+ struct expression_argument *arg;
+ int nargs = 1, pop = 0;
lua_rawgeti (L, LUA_REGISTRYINDEX, GPOINTER_TO_INT (lua_data));
/* Now we got function in top of stack */
ptask = lua_newuserdata (L, sizeof (struct rspamd_task *));
lua_setclass (L, "rspamd{task}", -1);
*ptask = task;
-
+
/* Now push all arguments */
cur = args;
while (cur) {
arg = get_function_arg (cur->data, task, FALSE);
if (arg) {
switch (arg->type) {
- case EXPRESSION_ARGUMENT_NORMAL:
- lua_pushstring (L, (const gchar *)arg->data);
- break;
- case EXPRESSION_ARGUMENT_BOOL:
- lua_pushboolean (L, (gboolean) GPOINTER_TO_SIZE (arg->data));
- break;
- default:
- msg_err ("cannot pass custom params to lua function");
- return FALSE;
+ case EXPRESSION_ARGUMENT_NORMAL:
+ lua_pushstring (L, (const gchar *)arg->data);
+ break;
+ case EXPRESSION_ARGUMENT_BOOL:
+ lua_pushboolean (L, (gboolean) GPOINTER_TO_SIZE (arg->data));
+ break;
+ default:
+ msg_err ("cannot pass custom params to lua function");
+ return FALSE;
}
}
- nargs ++;
+ nargs++;
cur = g_list_next (cur);
}
msg_info ("call to lua function failed: %s", lua_tostring (L, -1));
return FALSE;
}
- pop ++;
+ pop++;
if (!lua_isboolean (L, -1)) {
lua_pop (L, pop);
* LUA custom consolidation function
*/
struct consolidation_callback_data {
- struct rspamd_task *task;
- double score;
- const gchar *func;
+ struct rspamd_task *task;
+ double score;
+ const gchar *func;
};
static void
lua_consolidation_callback (gpointer key, gpointer value, gpointer arg)
{
- double res;
- struct symbol *s = (struct symbol *)value;
- struct consolidation_callback_data *data = (struct consolidation_callback_data *)arg;
- lua_State *L = data->task->cfg->lua_state;
+ double res;
+ struct symbol *s = (struct symbol *)value;
+ struct consolidation_callback_data *data =
+ (struct consolidation_callback_data *)arg;
+ lua_State *L = data->task->cfg->lua_state;
lua_getglobal (L, data->func);
msg_info ("function %s must return a number", data->func);
}
res = lua_tonumber (L, -1);
- lua_pop (L, 1); /* pop returned value */
+ lua_pop (L, 1); /* pop returned value */
data->score += res;
}
double
-lua_consolidation_func (struct rspamd_task *task, const gchar *metric_name, const gchar *function_name)
+lua_consolidation_func (struct rspamd_task *task,
+ const gchar *metric_name,
+ const gchar *function_name)
{
- struct metric_result *metric_res;
- double res = 0.;
+ struct metric_result *metric_res;
+ double res = 0.;
struct consolidation_callback_data data = { task, 0, function_name };
if (function_name == NULL) {
return res;
}
- g_hash_table_foreach (metric_res->symbols, lua_consolidation_callback, &data);
+ g_hash_table_foreach (metric_res->symbols, lua_consolidation_callback,
+ &data);
return data.score;
}
-double
+double
lua_normalizer_func (struct rspamd_config *cfg, long double score, void *params)
{
- GList *p = params;
- long double res = score;
- lua_State *L = cfg->lua_state;
-
- /* Call specified function and put input score on stack */
- if (!p->data) {
- msg_info ("bad function name while calling normalizer");
- return score;
- }
+ GList *p = params;
+ long double res = score;
+ lua_State *L = cfg->lua_state;
+
+ /* Call specified function and put input score on stack */
+ if (!p->data) {
+ msg_info ("bad function name while calling normalizer");
+ return score;
+ }
- lua_getglobal (L, p->data);
- lua_pushnumber (L, score);
+ lua_getglobal (L, p->data);
+ lua_pushnumber (L, score);
- if (lua_pcall (L, 1, 1, 0) != 0) {
+ if (lua_pcall (L, 1, 1, 0) != 0) {
msg_info ("call to %s failed", p->data);
}
res = lua_tonumber (L, -1);
lua_pop (L, 1);
- return res;
+ return res;
}
void
lua_dumpstack (lua_State *L)
{
- gint i, t, r = 0;
- gint top = lua_gettop (L);
- gchar buf[BUFSIZ];
+ gint i, t, r = 0;
+ gint top = lua_gettop (L);
+ gchar buf[BUFSIZ];
r += rspamd_snprintf (buf + r, sizeof (buf) - r, "lua stack: ");
for (i = 1; i <= top; i++) { /* repeat for each level */
switch (t)
{
case LUA_TSTRING: /* strings */
- r += rspamd_snprintf (buf + r, sizeof (buf) - r, "str: %s", lua_tostring(L, i));
+ r += rspamd_snprintf (buf + r,
+ sizeof (buf) - r,
+ "str: %s",
+ lua_tostring (L, i));
break;
case LUA_TBOOLEAN: /* booleans */
- r += rspamd_snprintf (buf + r, sizeof (buf) - r,lua_toboolean (L, i) ? "bool: true" : "bool: false");
+ r += rspamd_snprintf (buf + r, sizeof (buf) - r,lua_toboolean (L,
+ i) ? "bool: true" : "bool: false");
break;
case LUA_TNUMBER: /* numbers */
- r += rspamd_snprintf (buf + r, sizeof (buf) - r, "number: %.2f", lua_tonumber (L, i));
+ r += rspamd_snprintf (buf + r,
+ sizeof (buf) - r,
+ "number: %.2f",
+ lua_tonumber (L, i));
break;
default: /* other values */
- r += rspamd_snprintf (buf + r, sizeof (buf) - r, "type: %s", lua_typename (L, t));
+ r += rspamd_snprintf (buf + r,
+ sizeof (buf) - r,
+ "type: %s",
+ lua_typename (L, t));
break;
}
gpointer
lua_check_class (lua_State *L, gint index, const gchar *name)
{
- gpointer p;
+ gpointer p;
if (lua_type (L, index) == LUA_TUSERDATA) {
p = lua_touserdata (L, index);
rspamd_lua_typerror (lua_State *L, int narg, const char *tname)
{
const char *msg = lua_pushfstring (L, "%s expected, got %s", tname,
- luaL_typename(L, narg));
+ luaL_typename (L, narg));
return luaL_argerror (L, narg, msg);
}
#include "config.h"
#ifdef WITH_LUA
-#include "main.h"
#include "cfg_file.h"
-#include "ucl.h"
#include "lua_ucl.h"
-#include <lua.h>
+#include "main.h"
+#include "ucl.h"
#include <lauxlib.h>
+#include <lua.h>
#include <lualib.h>
#ifndef lua_open
-#define lua_open() luaL_newstate()
+#define lua_open() luaL_newstate ()
#endif
#ifndef luaL_reg
-#define luaL_reg luaL_Reg
+#define luaL_reg luaL_Reg
#endif
#define LUA_ENUM(L, name, val) \
- lua_pushlstring(L, #name, sizeof(#name)-1); \
- lua_pushnumber(L, val); \
- lua_settable(L, -3);
+ lua_pushlstring (L, # name, sizeof(# name) - 1); \
+ lua_pushnumber (L, val); \
+ lua_settable (L, -3);
#if LUA_VERSION_NUM > 501
static inline void
if (name != NULL) {
lua_newtable (L);
}
- luaL_setfuncs (L, methods, 0);
- if (name != NULL) {
- lua_pushvalue (L, -1);
- lua_setglobal (L, name);
- }
+ luaL_setfuncs (L, methods, 0);
+ if (name != NULL) {
+ lua_pushvalue (L, -1);
+ lua_setglobal (L, name);
+ }
}
#endif
/* Interface definitions */
-#define LUA_FUNCTION_DEF(class, name) static gint lua_##class##_##name(lua_State *L)
-#define LUA_INTERFACE_DEF(class, name) { #name, lua_##class##_##name }
+#define LUA_FUNCTION_DEF(class, name) static gint lua_ ## class ## _ ## name ( \
+ lua_State * L)
+#define LUA_INTERFACE_DEF(class, name) { # name, lua_ ## class ## _ ## name }
extern const luaL_reg null_reg[];
/**
* Create and register new class
*/
-void lua_newclass (lua_State *L, const gchar *classname, const struct luaL_reg *methods);
+void lua_newclass (lua_State *L,
+ const gchar *classname,
+ const struct luaL_reg *methods);
/**
* Create and register new class with static methods
*/
-void lua_newclass_full (lua_State *L, const gchar *classname, const gchar *static_name, const struct luaL_reg *methods, const struct luaL_reg *func);
+void lua_newclass_full (lua_State *L,
+ const gchar *classname,
+ const gchar *static_name,
+ const struct luaL_reg *methods,
+ const struct luaL_reg *func);
/**
* Set class name for object at @param objidx position
/**
* Initialize lua and bindings
*/
-lua_State* init_lua (struct rspamd_config *cfg);
+lua_State * init_lua (struct rspamd_config *cfg);
/**
* Load and initialize lua plugins
/**
* Initialize new locked lua_State structure
*/
-struct lua_locked_state* init_lua_locked (struct rspamd_config *cfg);
+struct lua_locked_state * init_lua_locked (struct rspamd_config *cfg);
/**
* Free locked state structure
*/
gint luaopen_ip (lua_State * L);
gint lua_call_filter (const gchar *function, struct rspamd_task *task);
-gint lua_call_chain_filter (const gchar *function, struct rspamd_task *task, gint *marks, guint number);
-double lua_consolidation_func (struct rspamd_task *task, const gchar *metric_name, const gchar *function_name);
-gboolean lua_call_expression_func (gpointer lua_data, struct rspamd_task *task, GList *args, gboolean *res);
+gint lua_call_chain_filter (const gchar *function,
+ struct rspamd_task *task,
+ gint *marks,
+ guint number);
+double lua_consolidation_func (struct rspamd_task *task,
+ const gchar *metric_name,
+ const gchar *function_name);
+gboolean lua_call_expression_func (gpointer lua_data,
+ struct rspamd_task *task,
+ GList *args,
+ gboolean *res);
void lua_call_post_filters (struct rspamd_task *task);
void lua_call_pre_filters (struct rspamd_task *task);
void add_luabuf (const gchar *line);
/* Classify functions */
-GList *call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task, gboolean is_learn, gboolean is_spam, lua_State *L);
-double call_classifier_post_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task, double in, lua_State *L);
-
-double lua_normalizer_func (struct rspamd_config *cfg, long double score, void *params);
+GList * call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
+ struct rspamd_task *task,
+ gboolean is_learn,
+ gboolean is_spam,
+ lua_State *L);
+double call_classifier_post_callbacks (struct rspamd_classifier_config *ccf,
+ struct rspamd_task *task,
+ double in,
+ lua_State *L);
+
+double lua_normalizer_func (struct rspamd_config *cfg,
+ long double score,
+ void *params);
/* Config file functions */
void lua_post_load_config (struct rspamd_config *cfg);
-void lua_process_element (struct rspamd_config *cfg, const gchar *name,
- const gchar *module_name, struct rspamd_module_opt *opt, gint idx, gboolean allow_meta);
-gboolean lua_handle_param (struct rspamd_task *task, gchar *mname, gchar *optname,
- enum lua_var_type expected_type, gpointer *res);
-gboolean lua_check_condition (struct rspamd_config *cfg, const gchar *condition);
+void lua_process_element (struct rspamd_config *cfg,
+ const gchar *name,
+ const gchar *module_name,
+ struct rspamd_module_opt *opt,
+ gint idx,
+ gboolean allow_meta);
+gboolean lua_handle_param (struct rspamd_task *task,
+ gchar *mname,
+ gchar *optname,
+ enum lua_var_type expected_type,
+ gpointer *res);
+gboolean lua_check_condition (struct rspamd_config *cfg,
+ const gchar *condition);
void lua_dumpstack (lua_State *L);
-struct memory_pool_s *lua_check_mempool (lua_State * L);
+struct memory_pool_s * lua_check_mempool (lua_State * L);
#endif /* WITH_LUA */
*/
-#include "lua_common.h"
+#include "classifiers/classifiers.h"
#include "expressions.h"
+#include "lua_common.h"
#include "map.h"
#include "message.h"
#include "radix.h"
#include "trie.h"
-#include "classifiers/classifiers.h"
/* Config file methods */
LUA_FUNCTION_DEF (config, get_module_opt);
LUA_FUNCTION_DEF (config, register_module_option);
LUA_FUNCTION_DEF (config, get_api_version);
-static const struct luaL_reg configlib_m[] = {
+static const struct luaL_reg configlib_m[] = {
LUA_INTERFACE_DEF (config, get_module_opt),
LUA_INTERFACE_DEF (config, get_mempool),
LUA_INTERFACE_DEF (config, get_all_opt),
/* Radix tree */
LUA_FUNCTION_DEF (radix, get_key);
-static const struct luaL_reg radixlib_m[] = {
+static const struct luaL_reg radixlib_m[] = {
LUA_INTERFACE_DEF (radix, get_key),
{"__tostring", lua_class_tostring},
{NULL, NULL}
/* Hash table */
LUA_FUNCTION_DEF (hash_table, get_key);
-static const struct luaL_reg hashlib_m[] = {
+static const struct luaL_reg hashlib_m[] = {
LUA_INTERFACE_DEF (hash_table, get_key),
{"__tostring", lua_class_tostring},
{NULL, NULL}
LUA_FUNCTION_DEF (trie, search_text);
LUA_FUNCTION_DEF (trie, search_task);
-static const struct luaL_reg trielib_m[] = {
+static const struct luaL_reg trielib_m[] = {
LUA_INTERFACE_DEF (trie, add_pattern),
LUA_INTERFACE_DEF (trie, search_text),
LUA_INTERFACE_DEF (trie, search_task),
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
-static const struct luaL_reg trielib_f[] = {
+static const struct luaL_reg trielib_f[] = {
LUA_INTERFACE_DEF (trie, create),
{NULL, NULL}
};
-static struct rspamd_config *
+static struct rspamd_config *
lua_check_config (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{config}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{config}");
luaL_argcheck (L, ud != NULL, 1, "'config' expected");
return ud ? *((struct rspamd_config **)ud) : NULL;
}
-static radix_tree_t *
+static radix_tree_t *
lua_check_radix (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{radix}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{radix}");
luaL_argcheck (L, ud != NULL, 1, "'radix' expected");
return ud ? **((radix_tree_t ***)ud) : NULL;
}
-static GHashTable *
+static GHashTable *
lua_check_hash_table (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{hash_table}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{hash_table}");
luaL_argcheck (L, ud != NULL, 1, "'hash_table' expected");
return ud ? **((GHashTable ***)ud) : NULL;
}
-static rspamd_trie_t *
+static rspamd_trie_t *
lua_check_trie (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{trie}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{trie}");
luaL_argcheck (L, ud != NULL, 1, "'trie' expected");
return ud ? *((rspamd_trie_t **)ud) : NULL;
static gint
lua_config_get_module_opt (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- const gchar *mname, *optname;
- const ucl_object_t *obj;
+ struct rspamd_config *cfg = lua_check_config (L);
+ const gchar *mname, *optname;
+ const ucl_object_t *obj;
if (cfg) {
mname = luaL_checkstring (L, 2);
static int
lua_config_get_mempool (lua_State * L)
{
- rspamd_mempool_t **ppool;
- struct rspamd_config *cfg = lua_check_config (L);
+ rspamd_mempool_t **ppool;
+ struct rspamd_config *cfg = lua_check_config (L);
if (cfg != NULL) {
ppool = lua_newuserdata (L, sizeof (rspamd_mempool_t *));
static gint
lua_config_get_all_opt (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- const gchar *mname;
- const ucl_object_t *obj;
+ struct rspamd_config *cfg = lua_check_config (L);
+ const gchar *mname;
+ const ucl_object_t *obj;
if (cfg) {
mname = luaL_checkstring (L, 2);
static gint
lua_config_get_classifier (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- struct rspamd_classifier_config *clc = NULL, **pclc = NULL;
- const gchar *name;
- GList *cur;
+ struct rspamd_config *cfg = lua_check_config (L);
+ struct rspamd_classifier_config *clc = NULL, **pclc = NULL;
+ const gchar *name;
+ GList *cur;
if (cfg) {
name = luaL_checkstring (L, 2);
cur = g_list_next (cur);
}
if (pclc) {
- pclc = lua_newuserdata (L, sizeof (struct rspamd_classifier_config *));
+ pclc = lua_newuserdata (L,
+ sizeof (struct rspamd_classifier_config *));
lua_setclass (L, "rspamd{classifier}", -1);
*pclc = clc;
return 1;
struct lua_callback_data {
union {
- gchar *name;
- gint ref;
+ gchar *name;
+ gint ref;
} callback;
- gboolean cb_is_ref;
- lua_State *L;
- gchar *symbol;
+ gboolean cb_is_ref;
+ lua_State *L;
+ gchar *symbol;
};
/*
static void
lua_destroy_cfg_symbol (gpointer ud)
{
- struct lua_callback_data *cd = ud;
+ struct lua_callback_data *cd = ud;
/* Unref callback */
if (cd->cb_is_ref) {
}
static gboolean
-lua_config_function_callback (struct rspamd_task *task, GList *args, void *user_data)
+lua_config_function_callback (struct rspamd_task *task,
+ GList *args,
+ void *user_data)
{
- struct lua_callback_data *cd = user_data;
- struct rspamd_task **ptask;
- gint i = 1;
- struct expression_argument *arg;
- GList *cur;
- gboolean res = FALSE;
+ struct lua_callback_data *cd = user_data;
+ struct rspamd_task **ptask;
+ gint i = 1;
+ struct expression_argument *arg;
+ GList *cur;
+ gboolean res = FALSE;
if (cd->cb_is_ref) {
lua_rawgeti (cd->L, LUA_REGISTRYINDEX, cd->callback.ref);
arg = get_function_arg (cur->data, task, TRUE);
lua_pushstring (cd->L, (const gchar *)arg->data);
cur = g_list_next (cur);
- i ++;
+ i++;
}
if (lua_pcall (cd->L, i, 1, 0) != 0) {
- msg_info ("error processing symbol %s: call to %s failed: %s", cd->symbol,
- cd->cb_is_ref ? "local function" :
- cd->callback.name, lua_tostring (cd->L, -1));
+ msg_info ("error processing symbol %s: call to %s failed: %s",
+ cd->symbol,
+ cd->cb_is_ref ? "local function" :
+ cd->callback.name,
+ lua_tostring (cd->L, -1));
}
else {
if (lua_isboolean (cd->L, 1)) {
static gint
lua_config_register_function (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- gchar *name;
- struct lua_callback_data *cd;
-
+ struct rspamd_config *cfg = lua_check_config (L);
+ gchar *name;
+ struct lua_callback_data *cd;
+
if (cfg) {
name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 3) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 3));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 3));
cd->cb_is_ref = FALSE;
}
else {
if (name) {
cd->L = L;
cd->symbol = name;
- register_expression_function (name, lua_config_function_callback, cd);
+ register_expression_function (name, lua_config_function_callback,
+ cd);
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
+ cd);
}
return 1;
}
void
lua_call_post_filters (struct rspamd_task *task)
{
- struct lua_callback_data *cd;
- struct rspamd_task **ptask;
- GList *cur;
+ struct lua_callback_data *cd;
+ struct rspamd_task **ptask;
+ GList *cur;
cur = task->cfg->post_filters;
while (cur) {
*ptask = task;
if (lua_pcall (cd->L, 1, 0, 0) != 0) {
- msg_info ("call to %s failed: %s", cd->cb_is_ref ? "local function" :
- cd->callback.name, lua_tostring (cd->L, -1));
+ msg_info ("call to %s failed: %s",
+ cd->cb_is_ref ? "local function" :
+ cd->callback.name,
+ lua_tostring (cd->L, -1));
}
cur = g_list_next (cur);
}
static gint
lua_config_register_post_filter (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- struct lua_callback_data *cd;
+ struct rspamd_config *cfg = lua_check_config (L);
+ struct lua_callback_data *cd;
if (cfg) {
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 2) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 2));
cd->cb_is_ref = FALSE;
}
else {
}
cd->L = L;
cfg->post_filters = g_list_prepend (cfg->post_filters, cd);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
+ cd);
}
return 1;
}
void
lua_call_pre_filters (struct rspamd_task *task)
{
- struct lua_callback_data *cd;
- struct rspamd_task **ptask;
- GList *cur;
+ struct lua_callback_data *cd;
+ struct rspamd_task **ptask;
+ GList *cur;
cur = task->cfg->pre_filters;
while (cur) {
*ptask = task;
if (lua_pcall (cd->L, 1, 0, 0) != 0) {
- msg_info ("call to %s failed: %s", cd->cb_is_ref ? "local function" :
- cd->callback.name, lua_tostring (cd->L, -1));
+ msg_info ("call to %s failed: %s",
+ cd->cb_is_ref ? "local function" :
+ cd->callback.name,
+ lua_tostring (cd->L, -1));
}
cur = g_list_next (cur);
}
static gint
lua_config_register_pre_filter (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- struct lua_callback_data *cd;
+ struct rspamd_config *cfg = lua_check_config (L);
+ struct lua_callback_data *cd;
if (cfg) {
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 2) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 2));
cd->cb_is_ref = FALSE;
}
else {
}
cd->L = L;
cfg->pre_filters = g_list_prepend (cfg->pre_filters, cd);
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
+ cd);
}
return 1;
}
static gint
lua_config_add_radix_map (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- const gchar *map_line, *description;
- radix_tree_t **r, ***ud;
+ struct rspamd_config *cfg = lua_check_config (L);
+ const gchar *map_line, *description;
+ radix_tree_t **r, ***ud;
if (cfg) {
map_line = luaL_checkstring (L, 2);
description = lua_tostring (L, 3);
r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (radix_tree_t *));
*r = radix_tree_create ();
- if (!add_map (cfg, map_line, description, read_radix_list, fin_radix_list, (void **)r)) {
+ if (!add_map (cfg, map_line, description, read_radix_list,
+ fin_radix_list, (void **)r)) {
msg_warn ("invalid radix map %s", map_line);
radix_tree_free (*r);
lua_pushnil (L);
static gint
lua_config_add_hash_map (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- const gchar *map_line, *description;
- GHashTable **r, ***ud;
+ struct rspamd_config *cfg = lua_check_config (L);
+ const gchar *map_line, *description;
+ GHashTable **r, ***ud;
if (cfg) {
map_line = luaL_checkstring (L, 2);
description = lua_tostring (L, 3);
r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (GHashTable *));
*r = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
- if (!add_map (cfg, map_line, description, read_host_list, fin_host_list, (void **)r)) {
+ if (!add_map (cfg, map_line, description, read_host_list, fin_host_list,
+ (void **)r)) {
msg_warn ("invalid hash map %s", map_line);
g_hash_table_destroy (*r);
lua_pushnil (L);
return 1;
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_hash_table_destroy, *r);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_hash_table_destroy,
+ *r);
ud = lua_newuserdata (L, sizeof (GHashTable *));
*ud = r;
lua_setclass (L, "rspamd{hash_table}", -1);
static gint
lua_config_add_kv_map (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- const gchar *map_line, *description;
- GHashTable **r, ***ud;
+ struct rspamd_config *cfg = lua_check_config (L);
+ const gchar *map_line, *description;
+ GHashTable **r, ***ud;
if (cfg) {
map_line = luaL_checkstring (L, 2);
description = lua_tostring (L, 3);
r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (GHashTable *));
*r = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
- if (!add_map (cfg, map_line, description, read_kv_list, fin_kv_list, (void **)r)) {
+ if (!add_map (cfg, map_line, description, read_kv_list, fin_kv_list,
+ (void **)r)) {
msg_warn ("invalid hash map %s", map_line);
g_hash_table_destroy (*r);
lua_pushnil (L);
return 1;
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_hash_table_destroy, *r);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)g_hash_table_destroy,
+ *r);
ud = lua_newuserdata (L, sizeof (GHashTable *));
*ud = r;
lua_setclass (L, "rspamd{hash_table}", -1);
static gchar *
lua_map_read (rspamd_mempool_t *pool, gchar *chunk, gint len,
- struct map_cb_data *data)
+ struct map_cb_data *data)
{
struct lua_map_callback_data *cbdata, *old;
if (lua_pcall (cbdata->L, 1, 0, 0) != 0) {
msg_info ("call to %s failed: %s", "local function",
- lua_tostring (cbdata->L, -1));
+ lua_tostring (cbdata->L, -1));
}
}
}
static gint
lua_config_add_map (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- const gchar *map_line, *description;
- struct lua_map_callback_data *cbdata, **pcbdata;
+ struct rspamd_config *cfg = lua_check_config (L);
+ const gchar *map_line, *description;
+ struct lua_map_callback_data *cbdata, **pcbdata;
if (cfg) {
map_line = luaL_checkstring (L, 2);
pcbdata = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (cbdata));
*pcbdata = cbdata;
if (!add_map (cfg, map_line, description, lua_map_read, lua_map_fin,
- (void **)pcbdata)) {
+ (void **)pcbdata)) {
msg_warn ("invalid hash map %s", map_line);
lua_pushboolean (L, false);
}
static void
lua_metric_symbol_callback (struct rspamd_task *task, gpointer ud)
{
- struct lua_callback_data *cd = ud;
- struct rspamd_task **ptask;
+ struct lua_callback_data *cd = ud;
+ struct rspamd_task **ptask;
if (cd->cb_is_ref) {
lua_rawgeti (cd->L, LUA_REGISTRYINDEX, cd->callback.ref);
if (lua_pcall (cd->L, 1, 0, 0) != 0) {
msg_info ("call to %s failed: %s", cd->cb_is_ref ? "local function" :
- cd->callback.name, lua_tostring (cd->L, -1));
+ cd->callback.name, lua_tostring (cd->L, -1));
}
}
static gint
lua_config_register_symbol (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- gchar *name;
- double weight;
- struct lua_callback_data *cd;
+ struct rspamd_config *cfg = lua_check_config (L);
+ gchar *name;
+ double weight;
+ struct lua_callback_data *cd;
if (cfg) {
name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
weight = luaL_checknumber (L, 3);
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 4) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 4));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 4));
cd->cb_is_ref = FALSE;
}
else {
if (name) {
cd->symbol = name;
cd->L = L;
- register_symbol (&cfg->cache, name, weight, lua_metric_symbol_callback, cd);
+ register_symbol (&cfg->cache,
+ name,
+ weight,
+ lua_metric_symbol_callback,
+ cd);
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
+ cd);
}
return 0;
}
static gint
lua_config_register_symbols (lua_State *L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- struct lua_callback_data *cd;
- gint i, top;
- gchar *sym;
- gdouble weight = 1.0;
+ struct rspamd_config *cfg = lua_check_config (L);
+ struct lua_callback_data *cd;
+ gint i, top;
+ gchar *sym;
+ gdouble weight = 1.0;
if (lua_gettop (L) < 3) {
msg_err ("not enough arguments to register a function");
return 0;
}
if (cfg) {
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 2) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 2));
cd->cb_is_ref = FALSE;
}
else {
sym = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, top));
cd->symbol = sym;
cd->L = L;
- register_symbol (&cfg->cache, sym, weight, lua_metric_symbol_callback, cd);
- for (i = top; i < lua_gettop (L); i ++) {
- sym = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, i + 1));
+ register_symbol (&cfg->cache,
+ sym,
+ weight,
+ lua_metric_symbol_callback,
+ cd);
+ for (i = top; i < lua_gettop (L); i++) {
+ sym =
+ rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L,
+ i + 1));
register_virtual_symbol (&cfg->cache, sym, weight);
}
}
static gint
lua_config_register_virtual_symbol (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- gchar *name;
- double weight;
+ struct rspamd_config *cfg = lua_check_config (L);
+ gchar *name;
+ double weight;
if (cfg) {
name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
static gint
lua_config_register_callback_symbol (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- gchar *name;
- double weight;
- struct lua_callback_data *cd;
+ struct rspamd_config *cfg = lua_check_config (L);
+ gchar *name;
+ double weight;
+ struct lua_callback_data *cd;
if (cfg) {
name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
weight = luaL_checknumber (L, 3);
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 4) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 4));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 4));
cd->cb_is_ref = FALSE;
}
else {
if (name) {
cd->symbol = name;
cd->L = L;
- register_callback_symbol (&cfg->cache, name, weight, lua_metric_symbol_callback, cd);
+ register_callback_symbol (&cfg->cache,
+ name,
+ weight,
+ lua_metric_symbol_callback,
+ cd);
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
+ cd);
}
return 0;
}
static gint
lua_config_register_callback_symbol_priority (lua_State * L)
{
- struct rspamd_config *cfg = lua_check_config (L);
- gchar *name;
- double weight;
- gint priority;
- struct lua_callback_data *cd;
+ struct rspamd_config *cfg = lua_check_config (L);
+ gchar *name;
+ double weight;
+ gint priority;
+ struct lua_callback_data *cd;
if (cfg) {
name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
weight = luaL_checknumber (L, 3);
priority = luaL_checknumber (L, 4);
- cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
+ cd =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct lua_callback_data));
if (lua_type (L, 5) == LUA_TSTRING) {
- cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 5));
+ cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
+ luaL_checkstring (L, 5));
cd->cb_is_ref = FALSE;
}
else {
if (name) {
cd->L = L;
cd->symbol = name;
- register_callback_symbol_priority (&cfg->cache, name, weight, priority, lua_metric_symbol_callback, cd);
+ register_callback_symbol_priority (&cfg->cache,
+ name,
+ weight,
+ priority,
+ lua_metric_symbol_callback,
+ cd);
}
- rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
+ rspamd_mempool_add_destructor (cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
+ cd);
}
return 0;
static gint
lua_radix_get_key (lua_State * L)
{
- radix_tree_t *radix = lua_check_radix (L);
- guint32 key;
+ radix_tree_t *radix = lua_check_radix (L);
+ guint32 key;
if (radix) {
key = luaL_checkint (L, 2);
static gint
lua_hash_table_get_key (lua_State * L)
{
- GHashTable *tbl = lua_check_hash_table (L);
- const gchar *key, *value;
+ GHashTable *tbl = lua_check_hash_table (L);
+ const gchar *key, *value;
if (tbl) {
key = luaL_checkstring (L, 2);
static gint
lua_trie_create (lua_State *L)
{
- rspamd_trie_t *trie, **ptrie;
- gboolean icase = FALSE;
+ rspamd_trie_t *trie, **ptrie;
+ gboolean icase = FALSE;
if (lua_gettop (L) == 1) {
icase = lua_toboolean (L, 1);
static gint
lua_trie_add_pattern (lua_State *L)
{
- rspamd_trie_t *trie = lua_check_trie (L);
- const gchar *pattern;
- gint id;
+ rspamd_trie_t *trie = lua_check_trie (L);
+ const gchar *pattern;
+ gint id;
if (trie) {
- pattern = luaL_checkstring (L, 2);
+ pattern = luaL_checkstring (L, 2);
id = luaL_checknumber (L, 3);
if (pattern != NULL) {
static gint
lua_trie_search_text (lua_State *L)
{
- rspamd_trie_t *trie = lua_check_trie (L);
- const gchar *text, *pos;
- gint id, i = 1;
- gsize len;
- gboolean found = FALSE;
+ rspamd_trie_t *trie = lua_check_trie (L);
+ const gchar *text, *pos;
+ gint id, i = 1;
+ gsize len;
+ gboolean found = FALSE;
if (trie) {
text = luaL_checkstring (L, 2);
if (text) {
lua_newtable (L);
pos = text;
- while (pos < text + len && (pos = rspamd_trie_lookup (trie, pos, len, &id)) != NULL) {
+ while (pos < text + len &&
+ (pos = rspamd_trie_lookup (trie, pos, len, &id)) != NULL) {
lua_pushinteger (L, i);
lua_pushinteger (L, id);
lua_settable (L, -3);
- i ++;
+ i++;
found = TRUE;
break;
}
static gint
lua_trie_search_task (lua_State *L)
{
- rspamd_trie_t *trie = lua_check_trie (L);
- struct rspamd_task *task;
- struct mime_text_part *part;
- GList *cur;
- const gchar *pos, *end;
- gint id, i = 1;
- void *ud;
- gboolean found = FALSE;
+ rspamd_trie_t *trie = lua_check_trie (L);
+ struct rspamd_task *task;
+ struct mime_text_part *part;
+ GList *cur;
+ const gchar *pos, *end;
+ gint id, i = 1;
+ void *ud;
+ gboolean found = FALSE;
if (trie) {
ud = luaL_checkudata (L, 2, "rspamd{task}");
if (!part->is_empty && part->content != NULL) {
pos = (const gchar *)part->content->data;
end = pos + part->content->len;
- while (pos < end && (pos = rspamd_trie_lookup (trie, pos, part->content->len, &id)) != NULL) {
+ while (pos < end &&
+ (pos =
+ rspamd_trie_lookup (trie, pos, part->content->len,
+ &id)) != NULL) {
lua_pushinteger (L, i);
lua_pushinteger (L, id);
lua_settable (L, -3);
- i ++;
+ i++;
found = TRUE;
break;
}
lua_pushstring (L, "rspamd{trie}");
lua_rawset (L, -3);
- luaL_register (L, NULL, trielib_m);
+ luaL_register (L, NULL, trielib_m);
luaL_register (L, "rspamd_trie", trielib_f);
lua_pop (L, 1); /* remove metatable from stack */
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "dns.h"
+#include "lua_common.h"
/* Public prototypes */
-struct rspamd_dns_resolver *lua_check_dns_resolver (lua_State * L);
+struct rspamd_dns_resolver * lua_check_dns_resolver (lua_State * L);
gint luaopen_dns_resolver (lua_State * L);
/* Lua bindings */
LUA_FUNCTION_DEF (dns_resolver, resolve_mx);
LUA_FUNCTION_DEF (dns_resolver, resolve);
-static const struct luaL_reg dns_resolverlib_f[] = {
+static const struct luaL_reg dns_resolverlib_f[] = {
LUA_INTERFACE_DEF (dns_resolver, init),
{NULL, NULL}
};
-static const struct luaL_reg dns_resolverlib_m[] = {
+static const struct luaL_reg dns_resolverlib_m[] = {
LUA_INTERFACE_DEF (dns_resolver, resolve_a),
LUA_INTERFACE_DEF (dns_resolver, resolve_ptr),
LUA_INTERFACE_DEF (dns_resolver, resolve_txt),
{NULL, NULL}
};
-struct rspamd_dns_resolver *
+struct rspamd_dns_resolver *
lua_check_dns_resolver (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{resolver}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{resolver}");
luaL_argcheck (L, ud != NULL, 1, "'resolver' expected");
return ud ? *((struct rspamd_dns_resolver **)ud) : NULL;
}
struct lua_dns_cbdata {
- lua_State *L;
- struct rspamd_dns_resolver *resolver;
- gint cbref;
- const gchar *to_resolve;
- const gchar *user_str;
+ lua_State *L;
+ struct rspamd_dns_resolver *resolver;
+ gint cbref;
+ const gchar *to_resolve;
+ const gchar *user_str;
};
static int
static void
lua_dns_callback (struct rdns_reply *reply, gpointer arg)
{
- struct lua_dns_cbdata *cd = arg;
- gint i = 0;
- struct rspamd_dns_resolver **presolver;
- struct rdns_reply_entry *elt;
- rspamd_inet_addr_t addr;
+ struct lua_dns_cbdata *cd = arg;
+ gint i = 0;
+ struct rspamd_dns_resolver **presolver;
+ struct rdns_reply_entry *elt;
+ rspamd_inet_addr_t addr;
lua_rawgeti (cd->L, LUA_REGISTRYINDEX, cd->cbref);
presolver = lua_newuserdata (cd->L, sizeof (gpointer));
*/
if (reply->code == RDNS_RC_NOERROR) {
lua_newtable (cd->L);
- LL_FOREACH (reply->entries, elt) {
+ LL_FOREACH (reply->entries, elt)
+ {
switch (elt->type) {
case RDNS_REQUEST_A:
addr.af = AF_INET;
addr.slen = sizeof (addr.addr.s4);
memcpy (&addr.addr.s4.sin_addr, &elt->content.a.addr,
- sizeof (addr.addr.s4.sin_addr));
+ sizeof (addr.addr.s4.sin_addr));
lua_ip_push (cd->L, &addr);
lua_rawseti (cd->L, -2, ++i);
break;
addr.af = AF_INET6;
addr.slen = sizeof (addr.addr.s6);
memcpy (&addr.addr.s6.sin6_addr, &elt->content.aaa.addr,
- sizeof (addr.addr.s6.sin6_addr));
+ sizeof (addr.addr.s6.sin6_addr));
lua_ip_push (cd->L, &addr);
lua_rawseti (cd->L, -2, ++i);
break;
static int
lua_dns_resolver_init (lua_State *L)
{
- struct rspamd_dns_resolver *resolver, **presolver;
- struct rspamd_config *cfg, **pcfg;
- struct event_base *base, **pbase;
+ struct rspamd_dns_resolver *resolver, **presolver;
+ struct rspamd_config *cfg, **pcfg;
+ struct event_base *base, **pbase;
/* Check args */
pbase = luaL_checkudata (L, 1, "rspamd{ev_base}");
luaL_argcheck (L, pbase != NULL, 1, "'ev_base' expected");
base = pbase ? *(pbase) : NULL;
pcfg = luaL_checkudata (L, 2, "rspamd{config}");
- luaL_argcheck (L, pcfg != NULL, 2, "'config' expected");
+ luaL_argcheck (L, pcfg != NULL, 2, "'config' expected");
cfg = pcfg ? *(pcfg) : NULL;
if (base != NULL && cfg != NULL) {
}
static int
-lua_dns_resolver_resolve_common (lua_State *L, struct rspamd_dns_resolver *resolver,
- enum rdns_request_type type, int first)
+lua_dns_resolver_resolve_common (lua_State *L,
+ struct rspamd_dns_resolver *resolver,
+ enum rdns_request_type type,
+ int first)
{
- struct rspamd_async_session *session, **psession;
- rspamd_mempool_t *pool, **ppool;
- const gchar *to_resolve;
- struct lua_dns_cbdata *cbdata;
+ struct rspamd_async_session *session, **psession;
+ rspamd_mempool_t *pool, **ppool;
+ const gchar *to_resolve;
+ struct lua_dns_cbdata *cbdata;
/* Check arguments */
psession = luaL_checkudata (L, first, "rspamd{session}");
- luaL_argcheck (L, psession != NULL, first, "'session' expected");
+ luaL_argcheck (L, psession != NULL, first, "'session' expected");
session = psession ? *(psession) : NULL;
ppool = luaL_checkudata (L, first + 1, "rspamd{mempool}");
- luaL_argcheck (L, ppool != NULL, first + 1, "'mempool' expected");
+ luaL_argcheck (L, ppool != NULL, first + 1, "'mempool' expected");
pool = ppool ? *(ppool) : NULL;
to_resolve = luaL_checkstring (L, first + 2);
- if (pool != NULL && session != NULL && to_resolve != NULL && lua_isfunction (L, first + 3)) {
+ if (pool != NULL && session != NULL && to_resolve != NULL &&
+ lua_isfunction (L, first + 3)) {
cbdata = rspamd_mempool_alloc (pool, sizeof (struct lua_dns_cbdata));
cbdata->L = L;
cbdata->resolver = resolver;
else {
cbdata->user_str = NULL;
}
- make_dns_request (resolver, session, pool, lua_dns_callback, cbdata, type, to_resolve);
+ make_dns_request (resolver,
+ session,
+ pool,
+ lua_dns_callback,
+ cbdata,
+ type,
+ to_resolve);
lua_pushboolean (L, TRUE);
}
else {
static int
lua_dns_resolver_resolve_a (lua_State *L)
{
- struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+ struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
if (dns_resolver) {
- return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_A, 2);
+ return lua_dns_resolver_resolve_common (L,
+ dns_resolver,
+ RDNS_REQUEST_A,
+ 2);
}
else {
lua_pushnil (L);
static int
lua_dns_resolver_resolve_ptr (lua_State *L)
{
- struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+ struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
if (dns_resolver) {
- return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_PTR, 2);
+ return lua_dns_resolver_resolve_common (L,
+ dns_resolver,
+ RDNS_REQUEST_PTR,
+ 2);
}
else {
lua_pushnil (L);
static int
lua_dns_resolver_resolve_txt (lua_State *L)
{
- struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+ struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
if (dns_resolver) {
- return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_TXT, 2);
+ return lua_dns_resolver_resolve_common (L,
+ dns_resolver,
+ RDNS_REQUEST_TXT,
+ 2);
}
else {
lua_pushnil (L);
static int
lua_dns_resolver_resolve_mx (lua_State *L)
{
- struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+ struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
if (dns_resolver) {
- return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_MX, 2);
+ return lua_dns_resolver_resolve_common (L,
+ dns_resolver,
+ RDNS_REQUEST_MX,
+ 2);
}
else {
lua_pushnil (L);
static int
lua_dns_resolver_resolve (lua_State *L)
{
- struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+ struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
int type;
type = lua_dns_get_type (L, 2);
lua_rawset (L, -3);
{
- LUA_ENUM(L, RDNS_REQUEST_A, RDNS_REQUEST_A);
- LUA_ENUM(L, RDNS_REQUEST_PTR, RDNS_REQUEST_PTR);
- LUA_ENUM(L, RDNS_REQUEST_MX, RDNS_REQUEST_MX);
- LUA_ENUM(L, RDNS_REQUEST_TXT, RDNS_REQUEST_TXT);
- LUA_ENUM(L, RDNS_REQUEST_SRV, RDNS_REQUEST_SRV);
- LUA_ENUM(L, RDNS_REQUEST_SPF, RDNS_REQUEST_SRV);
- LUA_ENUM(L, RDNS_REQUEST_AAA, RDNS_REQUEST_SRV);
+ LUA_ENUM (L, RDNS_REQUEST_A, RDNS_REQUEST_A);
+ LUA_ENUM (L, RDNS_REQUEST_PTR, RDNS_REQUEST_PTR);
+ LUA_ENUM (L, RDNS_REQUEST_MX, RDNS_REQUEST_MX);
+ LUA_ENUM (L, RDNS_REQUEST_TXT, RDNS_REQUEST_TXT);
+ LUA_ENUM (L, RDNS_REQUEST_SRV, RDNS_REQUEST_SRV);
+ LUA_ENUM (L, RDNS_REQUEST_SPF, RDNS_REQUEST_SRV);
+ LUA_ENUM (L, RDNS_REQUEST_AAA, RDNS_REQUEST_SRV);
}
- luaL_register (L, NULL, dns_resolverlib_m);
+ luaL_register (L, NULL, dns_resolverlib_m);
luaL_register (L, "rspamd_resolver", dns_resolverlib_f);
lua_pop (L, 1); /* remove metatable from stack */
- return 1;
+ return 1;
}
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "buffer.h"
#include "dns.h"
#include "http.h"
+#include "lua_common.h"
#define MAX_HEADERS_SIZE 8192
LUA_FUNCTION_DEF (http, make_post_request);
LUA_FUNCTION_DEF (http, make_get_request);
-static const struct luaL_reg httplib_m[] = {
+static const struct luaL_reg httplib_m[] = {
LUA_INTERFACE_DEF (http, make_post_request),
LUA_INTERFACE_DEF (http, make_get_request),
{"__tostring", lua_class_tostring},
static void
lua_http_fin (void *arg)
{
- struct lua_http_ud *ud = arg;
+ struct lua_http_ud *ud = arg;
if (ud->callback == NULL) {
/* Unref callback */
static void
lua_http_push_error (gint code, struct lua_http_ud *ud)
{
- struct rspamd_task **ptask;
- gint num;
+ struct rspamd_task **ptask;
+ gint num;
/* Push error */
if (ud->callback) {
/* Reply */
lua_pushnil (ud->L);
if (lua_pcall (ud->L, num, 0, 0) != 0) {
- msg_info ("call to %s failed: %s", ud->callback ? ud->callback : "local function", lua_tostring (ud->L, -1));
+ msg_info ("call to %s failed: %s",
+ ud->callback ? ud->callback : "local function",
+ lua_tostring (ud->L, -1));
}
if (ud->headers != NULL) {
static void
lua_http_push_reply (f_str_t *in, struct lua_http_ud *ud)
{
- GList *cur;
- struct lua_http_header *header;
- struct rspamd_task **ptask;
- gint num;
+ GList *cur;
+ struct lua_http_header *header;
+ struct rspamd_task **ptask;
+ gint num;
if (ud->callback) {
/* Push error */
/* Date */
if (ud->date != (time_t)-1) {
- num ++;
+ num++;
lua_pushnumber (ud->L, ud->date);
}
if (lua_pcall (ud->L, num, 0, 0) != 0) {
- msg_info ("call to %s failed: %s", ud->callback ? ud->callback : "local function", lua_tostring (ud->L, -1));
+ msg_info ("call to %s failed: %s",
+ ud->callback ? ud->callback : "local function",
+ lua_tostring (ud->L, -1));
}
if (ud->headers != NULL) {
static gboolean
lua_http_parse_first_line (struct lua_http_ud *ud, f_str_t *in)
{
- const gchar *p;
+ const gchar *p;
/* Assume first line is like this: HTTP/1.1 200 OK */
if (in->len < sizeof ("HTTP/1.1 OK") + 2) {
static gboolean
lua_http_parse_header_line (struct lua_http_ud *ud, f_str_t *in)
{
- const gchar *p = in->begin;
- struct lua_http_header *new;
+ const gchar *p = in->begin;
+ struct lua_http_header *new;
while (p < in->begin + in->len) {
if (*p == ':') {
break;
}
- p ++;
+ p++;
}
if (*p != ':') {
new->name = rspamd_mempool_alloc (ud->pool, p - in->begin + 1);
rspamd_strlcpy (new->name, in->begin, p - in->begin + 1);
- p ++;
+ p++;
/* Copy value */
while (p < in->begin + in->len && g_ascii_isspace (*p)) {
- p ++;
+ p++;
}
new->value = rspamd_mempool_alloc (ud->pool, in->begin + in->len - p + 1);
rspamd_strlcpy (new->value, p, in->begin + in->len - p + 1);
/* Check content-length */
- if (ud->rep_len == 0 && g_ascii_strcasecmp (new->name, "content-length") == 0) {
+ if (ud->rep_len == 0 &&
+ g_ascii_strcasecmp (new->name, "content-length") == 0) {
ud->rep_len = strtoul (new->value, NULL, 10);
}
static gboolean
lua_http_read_cb (f_str_t * in, void *arg)
{
- struct lua_http_ud *ud = arg;
+ struct lua_http_ud *ud = arg;
switch (ud->parser_state) {
case 0:
}
else {
ud->parser_state = 2;
- rspamd_set_dispatcher_policy (ud->io_dispatcher, BUFFER_CHARACTER, ud->rep_len);
+ rspamd_set_dispatcher_policy (ud->io_dispatcher,
+ BUFFER_CHARACTER,
+ ud->rep_len);
}
}
else {
static void
lua_http_err_cb (GError * err, void *arg)
{
- struct lua_http_ud *ud = arg;
- msg_info ("abnormally closing connection to http server error: %s", err->message);
+ struct lua_http_ud *ud = arg;
+ msg_info ("abnormally closing connection to http server error: %s",
+ err->message);
g_error_free (err);
if (ud->parser_state != 3) {
static void
lua_http_dns_callback (struct rdns_reply *reply, gpointer arg)
{
- struct lua_http_ud *ud = arg;
- struct rdns_reply_entry *elt;
- struct in_addr ina;
- struct timeval tv;
+ struct lua_http_ud *ud = arg;
+ struct rdns_reply_entry *elt;
+ struct in_addr ina;
+ struct timeval tv;
if (reply->code != RDNS_RC_NOERROR) {
lua_http_push_error (450, ud);
elt = reply->entries;
memcpy (&ina, &elt->content.a.addr, sizeof (struct in_addr));
- ud->fd = make_universal_socket (inet_ntoa (ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+ ud->fd = make_universal_socket (inet_ntoa (
+ ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
if (ud->fd == -1) {
lua_http_push_error (450, ud);
/* Create dispatcher for HTTP protocol */
msec_to_tv (ud->timeout, &tv);
- ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base, ud->fd, BUFFER_LINE, lua_http_read_cb, NULL,
- lua_http_err_cb, &tv, ud);
+ ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base,
+ ud->fd,
+ BUFFER_LINE,
+ lua_http_read_cb,
+ NULL,
+ lua_http_err_cb,
+ &tv,
+ ud);
/* Write request */
- register_async_event (ud->s, lua_http_fin, ud, g_quark_from_static_string ("lua http"));
+ register_async_event (ud->s, lua_http_fin, ud,
+ g_quark_from_static_string ("lua http"));
- if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len, TRUE, TRUE)) {
+ if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len,
+ TRUE, TRUE)) {
lua_http_push_error (450, ud);
return;
}
* Common request function
*/
static gint
-lua_http_make_request_common (lua_State *L, struct rspamd_task *task, const gchar *callback,
- const gchar *hostname, const gchar *path, const gchar *data, gint top)
+lua_http_make_request_common (lua_State *L,
+ struct rspamd_task *task,
+ const gchar *callback,
+ const gchar *hostname,
+ const gchar *path,
+ const gchar *data,
+ gint top)
{
- gint r, s, datalen;
- struct lua_http_ud *ud;
+ gint r, s, datalen;
+ struct lua_http_ud *ud;
/* Calculate buffer size */
datalen = (data != NULL) ? strlen (data) : 0;
- s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) + strlen (path) + datalen
- + sizeof ("POST HTTP/1.1");
+ s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) +
+ strlen (path) + datalen
+ + sizeof ("POST HTTP/1.1");
ud = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct lua_http_ud));
ud->L = L;
/* Print request */
r = rspamd_snprintf (ud->req_buf, s, "%s %s HTTP/1.1" CRLF
- "Connection: close" CRLF
- "Host: %s" CRLF,
- (data != NULL) ? "POST" : "GET", path, hostname);
+ "Connection: close" CRLF
+ "Host: %s" CRLF,
+ (data != NULL) ? "POST" : "GET", path, hostname);
if (datalen > 0) {
- r += rspamd_snprintf (ud->req_buf + r, s - r, "Content-Length: %d" CRLF, datalen);
+ r += rspamd_snprintf (ud->req_buf + r,
+ s - r,
+ "Content-Length: %d" CRLF,
+ datalen);
}
/* Now assume that we have a table with headers at the top of the stack */
/* Add headers */
lua_pushnil (L); /* first key */
while (lua_next (L, top + 1) != 0) {
- r += rspamd_snprintf (ud->req_buf + r, s - r, "%s: %s" CRLF, lua_tostring (L, -2), lua_tostring (L, -1));
- lua_pop(L, 1);
+ r += rspamd_snprintf (ud->req_buf + r,
+ s - r,
+ "%s: %s" CRLF,
+ lua_tostring (L, -2),
+ lua_tostring (L, -1));
+ lua_pop (L, 1);
}
}
/* Now check port and timeout */
ud->req_len = r;
/* Resolve hostname */
- if (make_dns_request (task->resolver, task->s, task->task_pool, lua_http_dns_callback, ud,
- RDNS_REQUEST_A, hostname)) {
- task->dns_requests ++;
+ if (make_dns_request (task->resolver, task->s, task->task_pool,
+ lua_http_dns_callback, ud,
+ RDNS_REQUEST_A, hostname)) {
+ task->dns_requests++;
}
return 0;
* Common request function (new version)
*/
static gint
-lua_http_make_request_common_new (lua_State *L, struct rspamd_async_session *session, rspamd_mempool_t *pool, struct event_base *base, gint cbref,
- const gchar *hostname, const gchar *path, const gchar *data, gint top)
+lua_http_make_request_common_new (lua_State *L,
+ struct rspamd_async_session *session,
+ rspamd_mempool_t *pool,
+ struct event_base *base,
+ gint cbref,
+ const gchar *hostname,
+ const gchar *path,
+ const gchar *data,
+ gint top)
{
- gint r, s, datalen;
- struct lua_http_ud *ud;
- struct in_addr ina;
- struct timeval tv;
+ gint r, s, datalen;
+ struct lua_http_ud *ud;
+ struct in_addr ina;
+ struct timeval tv;
/* Calculate buffer size */
datalen = (data != NULL) ? strlen (data) : 0;
- s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) + strlen (path) + datalen
- + sizeof ("POST HTTP/1.1");
+ s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) +
+ strlen (path) + datalen
+ + sizeof ("POST HTTP/1.1");
ud = rspamd_mempool_alloc0 (pool, sizeof (struct lua_http_ud));
ud->L = L;
/* Print request */
r = rspamd_snprintf (ud->req_buf, s, "%s %s HTTP/1.1" CRLF
- "Connection: close" CRLF,
- (data != NULL) ? "POST" : "GET", path);
+ "Connection: close" CRLF,
+ (data != NULL) ? "POST" : "GET", path);
if (datalen > 0) {
- r += rspamd_snprintf (ud->req_buf + r, s - r, "Content-Length: %d" CRLF, datalen);
+ r += rspamd_snprintf (ud->req_buf + r,
+ s - r,
+ "Content-Length: %d" CRLF,
+ datalen);
}
/* Now assume that we have a table with headers at the top of the stack */
/* Add headers */
lua_pushnil (L); /* first key */
while (lua_next (L, top + 1) != 0) {
- r += rspamd_snprintf (ud->req_buf + r, s - r, "%s: %s" CRLF, lua_tostring (L, -2), lua_tostring (L, -1));
+ r += rspamd_snprintf (ud->req_buf + r,
+ s - r,
+ "%s: %s" CRLF,
+ lua_tostring (L, -2),
+ lua_tostring (L, -1));
lua_pop (L, 1);
}
}
return 1;
}
- ud->fd = make_universal_socket (inet_ntoa (ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+ ud->fd = make_universal_socket (inet_ntoa (
+ ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
if (ud->fd == -1) {
luaL_unref (L, LUA_REGISTRYINDEX, cbref);
/* Create dispatcher for HTTP protocol */
msec_to_tv (ud->timeout, &tv);
- ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base, ud->fd, BUFFER_LINE, lua_http_read_cb, NULL,
- lua_http_err_cb, &tv, ud);
+ ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base,
+ ud->fd,
+ BUFFER_LINE,
+ lua_http_read_cb,
+ NULL,
+ lua_http_err_cb,
+ &tv,
+ ud);
/* Write request */
- register_async_event (ud->s, lua_http_fin, ud, g_quark_from_static_string ("lua http"));
+ register_async_event (ud->s, lua_http_fin, ud,
+ g_quark_from_static_string ("lua http"));
- if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len, TRUE, TRUE)) {
+ if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len,
+ TRUE, TRUE)) {
luaL_unref (L, LUA_REGISTRYINDEX, cbref);
lua_pushnil (L);
return 1;
static gint
lua_http_make_post_request (lua_State *L)
{
- struct rspamd_task *task, **ptask;
- rspamd_mempool_t *pool, **ppool;
- struct rspamd_async_session *session, **psession;
- struct event_base *base, **pbase;
- const gchar *hostname, *path, *data, *callback;
- gint cbref;
+ struct rspamd_task *task, **ptask;
+ rspamd_mempool_t *pool, **ppool;
+ struct rspamd_async_session *session, **psession;
+ struct event_base *base, **pbase;
+ const gchar *hostname, *path, *data, *callback;
+ gint cbref;
/* Check whether we have a task object */
luaL_argcheck (L, psession != NULL, 1, "'session' expected");
session = psession ? *(psession) : NULL;
ppool = luaL_checkudata (L, 2, "rspamd{mempool}");
- luaL_argcheck (L, ppool != NULL, 2, "'mempool' expected");
+ luaL_argcheck (L, ppool != NULL, 2, "'mempool' expected");
pool = ppool ? *(ppool) : NULL;
pbase = luaL_checkudata (L, 3, "rspamd{ev_base}");
- luaL_argcheck (L, ppool != NULL, 3, "'ev_base' expected");
+ luaL_argcheck (L, ppool != NULL, 3, "'ev_base' expected");
base = pbase ? *(pbase) : NULL;
}
/* Now extract hostname, path and data */
if (task) {
- callback = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
- hostname = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
+ callback =
+ rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
+ hostname =
+ rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
path = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 4));
data = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 5));
- if (callback != NULL && hostname != NULL && path != NULL && data != NULL) {
- return lua_http_make_request_common (L, task, callback, hostname, path, data, 5);
+ if (callback != NULL && hostname != NULL && path != NULL && data !=
+ NULL) {
+ return lua_http_make_request_common (L,
+ task,
+ callback,
+ hostname,
+ path,
+ data,
+ 5);
}
else {
msg_info ("invalid arguments number");
hostname = rspamd_mempool_strdup (pool, luaL_checkstring (L, 4));
path = rspamd_mempool_strdup (pool, luaL_checkstring (L, 5));
data = rspamd_mempool_strdup (pool, luaL_checkstring (L, 6));
- if (session != NULL && pool != NULL && hostname != NULL && path != NULL && data != NULL && lua_isfunction (L, 7)) {
+ if (session != NULL && pool != NULL && hostname != NULL && path !=
+ NULL && data != NULL && lua_isfunction (L, 7)) {
lua_pushvalue (L, 7);
cbref = luaL_ref (L, LUA_REGISTRYINDEX);
- return lua_http_make_request_common_new (L, session, pool, base, cbref, hostname, path, data, 7);
+ return lua_http_make_request_common_new (L,
+ session,
+ pool,
+ base,
+ cbref,
+ hostname,
+ path,
+ data,
+ 7);
}
}
static gint
lua_http_make_get_request (lua_State *L)
{
- struct rspamd_task *task, **ptask;
- rspamd_mempool_t *pool, **ppool;
- struct rspamd_async_session *session, **psession;
- struct event_base *base, **pbase;
- const gchar *hostname, *path, *callback;
- gint cbref;
+ struct rspamd_task *task, **ptask;
+ rspamd_mempool_t *pool, **ppool;
+ struct rspamd_async_session *session, **psession;
+ struct event_base *base, **pbase;
+ const gchar *hostname, *path, *callback;
+ gint cbref;
/* Check whether we have a task object */
luaL_argcheck (L, psession != NULL, 1, "'session' expected");
session = psession ? *(psession) : NULL;
ppool = luaL_checkudata (L, 2, "rspamd{mempool}");
- luaL_argcheck (L, ppool != NULL, 2, "'mempool' expected");
+ luaL_argcheck (L, ppool != NULL, 2, "'mempool' expected");
pool = ppool ? *(ppool) : NULL;
pbase = luaL_checkudata (L, 3, "rspamd{ev_base}");
- luaL_argcheck (L, ppool != NULL, 3, "'ev_base' expected");
+ luaL_argcheck (L, ppool != NULL, 3, "'ev_base' expected");
base = pbase ? *(pbase) : NULL;
}
/* Now extract hostname, path and data */
if (task) {
- callback = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
- hostname = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
+ callback =
+ rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
+ hostname =
+ rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
path = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 4));
if (callback != NULL && hostname != NULL && path != NULL) {
- return lua_http_make_request_common (L, task, callback, hostname, path, NULL, 4);
+ return lua_http_make_request_common (L,
+ task,
+ callback,
+ hostname,
+ path,
+ NULL,
+ 4);
}
else {
msg_info ("invalid arguments number");
/* Common version */
hostname = rspamd_mempool_strdup (pool, luaL_checkstring (L, 4));
path = rspamd_mempool_strdup (pool, luaL_checkstring (L, 5));
- if (session != NULL && pool != NULL && hostname != NULL && path != NULL && lua_isfunction (L, 6)) {
+ if (session != NULL && pool != NULL && hostname != NULL && path !=
+ NULL && lua_isfunction (L, 6)) {
lua_pushvalue (L, 6);
cbref = luaL_ref (L, LUA_REGISTRYINDEX);
- return lua_http_make_request_common_new (L, session, pool, base, cbref, hostname, path, NULL, 6);
+ return lua_http_make_request_common_new (L,
+ session,
+ pool,
+ base,
+ cbref,
+ hostname,
+ path,
+ NULL,
+ 6);
}
}
LUA_FUNCTION_DEF (ip, get_version);
LUA_FUNCTION_DEF (ip, is_valid);
-static const struct luaL_reg iplib_m[] = {
+static const struct luaL_reg iplib_m[] = {
LUA_INTERFACE_DEF (ip, to_string),
LUA_INTERFACE_DEF (ip, to_table),
LUA_INTERFACE_DEF (ip, to_number),
{NULL, NULL}
};
-static const struct luaL_reg iplib_f[] = {
+static const struct luaL_reg iplib_f[] = {
LUA_INTERFACE_DEF (ip, from_string),
LUA_INTERFACE_DEF (ip, from_number),
{NULL, NULL}
};
-static struct rspamd_lua_ip *
+static struct rspamd_lua_ip *
lua_check_ip (lua_State * L, gint pos)
{
void *ud = luaL_checkudata (L, pos, "rspamd{ip}");
ptr = (guint8 *)&ip->addr.addr.s6.sin6_addr;
}
- for (i = 1; i <= max; i ++, ptr ++) {
+ for (i = 1; i <= max; i++, ptr++) {
lua_pushnumber (L, *ptr);
lua_rawseti (L, -2, i);
}
ptr = (guint8 *)&ip->addr.addr.s6.sin6_addr;
}
- for (i = 1; i <= max; i ++, ptr ++) {
+ for (i = 1; i <= max; i++, ptr++) {
if (ip->addr.af == AF_INET) {
rspamd_snprintf (numbuf, sizeof (numbuf), "%d", *ptr);
lua_pushstring (L, numbuf);
lua_rawseti (L, -2, i);
}
else {
- rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", (*ptr & 0xf0) >> 4);
+ rspamd_snprintf (numbuf,
+ sizeof (numbuf),
+ "%xd",
+ (*ptr & 0xf0) >> 4);
lua_pushstring (L, numbuf);
- lua_rawseti (L, -2, i*2 - 1);
+ lua_rawseti (L, -2, i * 2 - 1);
rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", *ptr & 0x0f);
lua_pushstring (L, numbuf);
- lua_rawseti (L, -2, i*2);
+ lua_rawseti (L, -2, i * 2);
}
}
}
}
ptr += max - 1;
- for (i = 1; i <= max; i ++, ptr --) {
+ for (i = 1; i <= max; i++, ptr--) {
if (ip->addr.af == AF_INET) {
rspamd_snprintf (numbuf, sizeof (numbuf), "%d", *ptr);
lua_pushstring (L, numbuf);
else {
rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", *ptr & 0x0f);
lua_pushstring (L, numbuf);
- lua_rawseti (L, -2, i*2 - 1);
- rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", (*ptr & 0xf0) >> 4);
+ lua_rawseti (L, -2, i * 2 - 1);
+ rspamd_snprintf (numbuf,
+ sizeof (numbuf),
+ "%xd",
+ (*ptr & 0xf0) >> 4);
lua_pushstring (L, numbuf);
- lua_rawseti (L, -2, i*2);
+ lua_rawseti (L, -2, i * 2);
}
}
}
}
else {
/* 4 integers in host byte order */
- G_STATIC_ASSERT (sizeof (ip->addr.addr.s6.sin6_addr) >= sizeof (dst));
+ G_STATIC_ASSERT (sizeof (ip->addr.addr.s6.sin6_addr) >=
+ sizeof (dst));
memcpy (dst, &ip->addr.addr.s6.sin6_addr, sizeof (dst));
- for (i = 0; i < G_N_ELEMENTS (dst); i ++) {
+ for (i = 0; i < G_N_ELEMENTS (dst); i++) {
lua_pushinteger (L, ntohl (dst[i]));
}
return 4;
}
else if (lua_gettop (L) == 4 && lua_isnumber (L, 1)) {
/* Ipv6 version */
- for (i = 0; i < 4; i ++) {
+ for (i = 0; i < 4; i++) {
src[i] = htonl (lua_tonumber (L, i + 1));
}
G_STATIC_ASSERT (sizeof (ip->addr.addr.s6.sin6_addr) >= sizeof (src));
lua_pushstring (L, "rspamd{ip}");
lua_rawset (L, -3);
- luaL_register (L, NULL, iplib_m);
+ luaL_register (L, NULL, iplib_m);
luaL_register (L, "rspamd_ip", iplib_f);
lua_pop (L, 1); /* remove metatable from stack */
#include "mem_pool.h"
/* Public prototypes */
-struct memory_pool_s *lua_check_mempool (lua_State * L);
+struct memory_pool_s * lua_check_mempool (lua_State * L);
gint luaopen_mempool (lua_State * L);
/* Lua bindings */
LUA_FUNCTION_DEF (mempool, memory_pool_set_variable);
LUA_FUNCTION_DEF (mempool, memory_pool_get_variable);
-static const struct luaL_reg mempoollib_m[] = {
+static const struct luaL_reg mempoollib_m[] = {
LUA_INTERFACE_DEF (mempool, memory_pool_add_destructor),
LUA_INTERFACE_DEF (mempool, memory_pool_stat),
LUA_INTERFACE_DEF (mempool, memory_pool_suggest_size),
{NULL, NULL}
};
-static const struct luaL_reg mempoollib_f[] = {
+static const struct luaL_reg mempoollib_f[] = {
LUA_INTERFACE_DEF (mempool, create),
{NULL, NULL}
};
rspamd_mempool_t *mempool;
};
-struct memory_pool_s *
+struct memory_pool_s *
lua_check_mempool (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{mempool}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{mempool}");
luaL_argcheck (L, ud != NULL, 1, "'mempool' expected");
return ud ? *((struct memory_pool_s **)ud) : NULL;
}
static int
lua_mempool_create (lua_State *L)
{
- struct memory_pool_s *mempool = rspamd_mempool_new (rspamd_mempool_suggest_size ()), **pmempool;
+ struct memory_pool_s *mempool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ()), **pmempool;
if (mempool) {
pmempool = lua_newuserdata (L, sizeof (struct memory_pool_s *));
static void
lua_mempool_destructor_func (gpointer p)
{
- struct lua_mempool_udata *ud = p;
+ struct lua_mempool_udata *ud = p;
lua_rawgeti (ud->L, LUA_REGISTRYINDEX, ud->cbref);
if (lua_pcall (ud->L, 0, 0, 0) != 0) {
static int
lua_mempool_memory_pool_add_destructor (lua_State *L)
{
- struct memory_pool_s *mempool = lua_check_mempool (L);
- struct lua_mempool_udata *ud;
+ struct memory_pool_s *mempool = lua_check_mempool (L);
+ struct lua_mempool_udata *ud;
if (mempool) {
if (lua_isfunction (L, 2)) {
- ud = rspamd_mempool_alloc (mempool, sizeof (struct lua_mempool_udata));
+ ud = rspamd_mempool_alloc (mempool,
+ sizeof (struct lua_mempool_udata));
lua_pushvalue (L, 2);
/* Get a reference */
ud->cbref = luaL_ref (L, LUA_REGISTRYINDEX);
ud->L = L;
ud->mempool = mempool;
- rspamd_mempool_add_destructor (mempool, lua_mempool_destructor_func, ud);
+ rspamd_mempool_add_destructor (mempool,
+ lua_mempool_destructor_func,
+ ud);
}
else {
msg_err ("trying to add destructor without function");
static int
lua_mempool_memory_pool_delete (lua_State *L)
{
- struct memory_pool_s *mempool = lua_check_mempool (L);
+ struct memory_pool_s *mempool = lua_check_mempool (L);
if (mempool) {
rspamd_mempool_delete (mempool);
static int
lua_mempool_memory_pool_stat (lua_State *L)
{
- struct memory_pool_s *mempool = lua_check_mempool (L);
+ struct memory_pool_s *mempool = lua_check_mempool (L);
if (mempool) {
-
+
}
else {
lua_pushnil (L);
static int
lua_mempool_memory_pool_suggest_size (lua_State *L)
{
- struct memory_pool_s *mempool = lua_check_mempool (L);
+ struct memory_pool_s *mempool = lua_check_mempool (L);
if (mempool) {
lua_pushinteger (L, rspamd_mempool_suggest_size ());
static int
lua_mempool_memory_pool_set_variable (lua_State *L)
{
- struct memory_pool_s *mempool = lua_check_mempool (L);
- const gchar *var = luaL_checkstring (L, 2),
- *value = luaL_checkstring (L, 3);
+ struct memory_pool_s *mempool = lua_check_mempool (L);
+ const gchar *var = luaL_checkstring (L, 2),
+ *value = luaL_checkstring (L, 3);
if (mempool && var && value) {
- rspamd_mempool_set_variable (mempool, var, rspamd_mempool_strdup (mempool, value), NULL);
+ rspamd_mempool_set_variable (mempool, var,
+ rspamd_mempool_strdup (mempool, value), NULL);
return 0;
}
else {
static int
lua_mempool_memory_pool_get_variable (lua_State *L)
{
- struct memory_pool_s *mempool = lua_check_mempool (L);
- const gchar *var = luaL_checkstring (L, 2);
- gchar *value;
+ struct memory_pool_s *mempool = lua_check_mempool (L);
+ const gchar *var = luaL_checkstring (L, 2);
+ gchar *value;
if (mempool && var) {
value = rspamd_mempool_get_variable (mempool, var);
lua_pushstring (L, "rspamd{mempool}");
lua_rawset (L, -3);
- luaL_register (L, NULL, mempoollib_m);
+ luaL_register (L, NULL, mempoollib_m);
luaL_register (L, "rspamd_mempool", mempoollib_f);
lua_pop (L, 1); /* remove metatable from stack */
- return 1;
+ return 1;
}
#include "lua_common.h"
#include "message.h"
-#define LUA_GMIME_BRIDGE_GET(class, name, mime_class) \
-static gint \
-lua_##class##_##name(lua_State *L) \
-{ \
- GMime##mime_class *obj = lua_check_##class(L); \
- if (obj != NULL) { \
- lua_pushstring (L, g_mime_##class##_##name(obj)); \
- } \
- else { \
- lua_pushnil (L); \
- } \
- return 1; \
-}
+#define LUA_GMIME_BRIDGE_GET(class, name, mime_class) \
+ static gint \
+ lua_ ## class ## _ ## name (lua_State * L) \
+ { \
+ GMime ## mime_class * obj = lua_check_ ## class (L); \
+ if (obj != NULL) { \
+ lua_pushstring (L, g_mime_ ## class ## _ ## name (obj)); \
+ } \
+ else { \
+ lua_pushnil (L); \
+ } \
+ return 1; \
+ }
-#define LUA_GMIME_BRIDGE_SET(class, name, mime_class) \
-static gint \
-lua_##class##_##name(lua_State *L) \
-{ \
- const gchar *str; \
- GMime##mime_class *obj = lua_check_##class(L); \
- if (obj != NULL) { \
- str = luaL_checkstring (L, 2); \
- g_mime_##class##_##name(obj, str); \
- } \
- else { \
- lua_pushnil (L); \
- } \
- return 1; \
-}
+#define LUA_GMIME_BRIDGE_SET(class, name, mime_class) \
+ static gint \
+ lua_ ## class ## _ ## name (lua_State * L) \
+ { \
+ const gchar *str; \
+ GMime ## mime_class * obj = lua_check_ ## class (L); \
+ if (obj != NULL) { \
+ str = luaL_checkstring (L, 2); \
+ g_mime_ ## class ## _ ## name (obj, str); \
+ } \
+ else { \
+ lua_pushnil (L); \
+ } \
+ return 1; \
+ }
/* Message methods */
LUA_FUNCTION_DEF (message, get_subject);
LUA_FUNCTION_DEF (message, set_header);
LUA_FUNCTION_DEF (message, get_date);
-static const struct luaL_reg msglib_m[] = {
+static const struct luaL_reg msglib_m[] = {
LUA_INTERFACE_DEF (message, get_subject),
LUA_INTERFACE_DEF (message, set_subject),
LUA_INTERFACE_DEF (message, get_message_id),
-static GMimeMessage *
+static GMimeMessage *
lua_check_message (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{message}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{message}");
luaL_argcheck (L, ud != NULL, 1, "'message' expected");
return ud ? *((GMimeMessage **) ud) : NULL;
}
static gint
lua_message_get_header_common (lua_State * L, gboolean strong)
{
- const gchar *headern;
- GMimeMessage *obj = lua_check_message (L);
- GList *res = NULL, *cur;
- gint i = 1;
+ const gchar *headern;
+ GMimeMessage *obj = lua_check_message (L);
+ GList *res = NULL, *cur;
+ gint i = 1;
if (obj != NULL) {
headern = luaL_checkstring (L, 2);
static gint
lua_message_set_header (lua_State * L)
{
- const gchar *headern, *headerv;
- GMimeMessage *obj = lua_check_message (L);
+ const gchar *headern, *headerv;
+ GMimeMessage *obj = lua_check_message (L);
if (obj != NULL) {
headern = luaL_checkstring (L, 2);
static gint
lua_message_get_date (lua_State * L)
{
- GMimeMessage *obj = lua_check_message (L);
- time_t msg_time;
- int offset;
+ GMimeMessage *obj = lua_check_message (L);
+ time_t msg_time;
+ int offset;
if (obj != NULL) {
g_mime_message_get_date (obj, &msg_time, &offset);
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "dns.h"
+#include "lua_common.h"
#ifndef WITH_SYSTEM_HIREDIS
-#include "hiredis.h"
-#include "async.h"
#include "adapters/libevent.h"
+#include "async.h"
+#include "hiredis.h"
#else
-#include <hiredis/hiredis.h>
-#include <hiredis/async.h>
#include <hiredis/adapters/libevent.h>
+#include <hiredis/async.h>
+#include <hiredis/hiredis.h>
#endif
LUA_FUNCTION_DEF (redis, make_request);
-static const struct luaL_reg redislib_m[] = {
+static const struct luaL_reg redislib_m[] = {
LUA_INTERFACE_DEF (redis, make_request),
{"__tostring", lua_class_tostring},
{NULL, NULL}
* @param L lua stack
* @return worker task object
*/
-static struct rspamd_task *
+static struct rspamd_task *
lua_check_task (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{task}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{task}");
luaL_argcheck (L, ud != NULL, 1, "'task' expected");
return ud ? *((struct rspamd_task **)ud) : NULL;
}
static void
lua_redis_fin (void *arg)
{
- struct lua_redis_userdata *ud = arg;
+ struct lua_redis_userdata *ud = arg;
if (ud->ctx) {
redisAsyncFree (ud->ctx);
* @param ud
*/
static void
-lua_redis_push_error (const gchar *err, struct lua_redis_userdata *ud, gboolean connected)
+lua_redis_push_error (const gchar *err,
+ struct lua_redis_userdata *ud,
+ gboolean connected)
{
- struct rspamd_task **ptask;
+ struct rspamd_task **ptask;
/* Push error */
lua_rawgeti (ud->L, LUA_REGISTRYINDEX, ud->cbref);
static void
lua_redis_push_data (const redisReply *r, struct lua_redis_userdata *ud)
{
- struct rspamd_task **ptask;
+ struct rspamd_task **ptask;
/* Push error */
lua_rawgeti (ud->L, LUA_REGISTRYINDEX, ud->cbref);
static void
lua_redis_callback (redisAsyncContext *c, gpointer r, gpointer priv)
{
- redisReply *reply = r;
- struct lua_redis_userdata *ud = priv;
+ redisReply *reply = r;
+ struct lua_redis_userdata *ud = priv;
if (c->err == 0) {
if (r != NULL) {
{
ud->ctx = redisAsyncConnect (inet_ntoa (ud->ina), ud->port);
if (ud->ctx == NULL || ud->ctx->err) {
- lua_redis_push_error (ud->ctx ? ud->ctx->errstr : "unknown error", ud, FALSE);
+ lua_redis_push_error (ud->ctx ? ud->ctx->errstr : "unknown error",
+ ud,
+ FALSE);
return FALSE;
}
else {
- register_async_event (ud->task->s, lua_redis_fin, ud, g_quark_from_static_string ("lua redis"));
+ register_async_event (ud->task->s,
+ lua_redis_fin,
+ ud,
+ g_quark_from_static_string ("lua redis"));
}
redisLibeventAttach (ud->ctx, ud->task->ev_base);
/* Make a request now */
redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline);
break;
case 1:
- redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline, ud->args[0].begin, ud->args[0].len);
+ redisAsyncCommand (ud->ctx,
+ lua_redis_callback,
+ ud,
+ ud->reqline,
+ ud->args[0].begin,
+ ud->args[0].len);
break;
case 2:
- redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline, ud->args[0].begin, ud->args[0].len,
- ud->args[1].begin, ud->args[1].len);
+ redisAsyncCommand (ud->ctx,
+ lua_redis_callback,
+ ud,
+ ud->reqline,
+ ud->args[0].begin,
+ ud->args[0].len,
+ ud->args[1].begin,
+ ud->args[1].len);
break;
default:
/* XXX: cannot handle more than 3 arguments */
- redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline, ud->args[0].begin, ud->args[0].len,
- ud->args[1].begin, ud->args[1].len,
- ud->args[2].begin, ud->args[2].len);
+ redisAsyncCommand (ud->ctx,
+ lua_redis_callback,
+ ud,
+ ud->reqline,
+ ud->args[0].begin,
+ ud->args[0].len,
+ ud->args[1].begin,
+ ud->args[1].len,
+ ud->args[2].begin,
+ ud->args[2].len);
break;
}
static void
lua_redis_dns_callback (struct rdns_reply *reply, gpointer arg)
{
- struct lua_redis_userdata *ud = arg;
- struct rdns_reply_entry *elt;
+ struct lua_redis_userdata *ud = arg;
+ struct rdns_reply_entry *elt;
if (reply->code != RDNS_RC_NOERROR) {
static int
lua_redis_make_request (lua_State *L)
{
- struct rspamd_task *task;
- struct lua_redis_userdata *ud;
- const gchar *server, *tmp;
- guint port, i;
+ struct rspamd_task *task;
+ struct lua_redis_userdata *ud;
+ const gchar *server, *tmp;
+ guint port, i;
if ((task = lua_check_task (L)) != NULL) {
server = luaL_checkstring (L, 2);
port = luaL_checkint (L, 3);
/* Now get callback */
- if (lua_isfunction (L, 4) && server != NULL && port > 0 && port < G_MAXUINT16) {
+ if (lua_isfunction (L,
+ 4) && server != NULL && port > 0 && port < G_MAXUINT16) {
/* Create userdata */
- ud = rspamd_mempool_alloc (task->task_pool, sizeof (struct lua_redis_userdata));
+ ud =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct lua_redis_userdata));
ud->server = rspamd_mempool_strdup (task->task_pool, server);
ud->port = port;
ud->task = task;
lua_pushvalue (L, 4);
/* Get a reference */
ud->cbref = luaL_ref (L, LUA_REGISTRYINDEX);
- ud->reqline = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 5));
+ ud->reqline = rspamd_mempool_strdup (task->task_pool,
+ luaL_checkstring (L, 5));
/* Now get remaining args */
ud->args_num = lua_gettop (L) - 5;
- ud->args = rspamd_mempool_alloc (task->task_pool, ud->args_num * sizeof (f_str_t));
- for (i = 0; i < ud->args_num; i ++) {
+ ud->args = rspamd_mempool_alloc (task->task_pool,
+ ud->args_num * sizeof (f_str_t));
+ for (i = 0; i < ud->args_num; i++) {
tmp = lua_tolstring (L, i + 6, &ud->args[i].len);
/* Make a copy of argument */
- ud->args[i].begin = rspamd_mempool_alloc (task->task_pool, ud->args[i].len);
+ ud->args[i].begin = rspamd_mempool_alloc (task->task_pool,
+ ud->args[i].len);
memcpy (ud->args[i].begin, tmp, ud->args[i].len);
}
/* Now check whether we need to perform DNS request */
/* Need to make dns request */
/* Resolve hostname */
if (make_dns_request (task->resolver, task->s, task->task_pool,
- lua_redis_dns_callback, ud,
- RDNS_REQUEST_A, ud->server)) {
- task->dns_requests ++;
+ lua_redis_dns_callback, ud,
+ RDNS_REQUEST_A, ud->server)) {
+ task->dns_requests++;
lua_pushboolean (L, TRUE);
}
else {
}
}
else {
- if (! lua_redis_make_request_real (ud)) {
+ if (!lua_redis_make_request_real (ud)) {
lua_pushboolean (L, FALSE);
}
else {
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "lua_common.h"
#include "expressions.h"
+#include "lua_common.h"
LUA_FUNCTION_DEF (regexp, create);
LUA_FUNCTION_DEF (regexp, get_cached);
LUA_FUNCTION_DEF (regexp, split);
LUA_FUNCTION_DEF (regexp, destroy);
-static const struct luaL_reg regexplib_m[] = {
+static const struct luaL_reg regexplib_m[] = {
LUA_INTERFACE_DEF (regexp, get_pattern),
LUA_INTERFACE_DEF (regexp, match),
LUA_INTERFACE_DEF (regexp, split),
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
-static const struct luaL_reg regexplib_f[] = {
+static const struct luaL_reg regexplib_f[] = {
LUA_INTERFACE_DEF (regexp, create),
LUA_INTERFACE_DEF (regexp, get_cached),
{NULL, NULL}
gint re_flags;
};
-static struct rspamd_lua_regexp *
+static struct rspamd_lua_regexp *
lua_check_regexp (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{regexp}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{regexp}");
luaL_argcheck (L, ud != NULL, 1, "'regexp' expected");
return ud ? *((struct rspamd_lua_regexp **)ud) : NULL;
static int
lua_regexp_create (lua_State *L)
{
- gint regexp_flags = 0;
- GRegex *re;
- struct rspamd_lua_regexp *new, **pnew;
- const gchar *string, *flags_str = NULL;
- GError *err = NULL;
+ gint regexp_flags = 0;
+ GRegex *re;
+ struct rspamd_lua_regexp *new, **pnew;
+ const gchar *string, *flags_str = NULL;
+ GError *err = NULL;
string = luaL_checkstring (L, 1);
if (lua_gettop (L) == 2) {
msg_info ("invalid regexp flag: %c", *flags_str);
break;
}
- flags_str ++;
+ flags_str++;
}
}
re = g_regex_new (string, regexp_flags, 0, &err);
if (re == NULL) {
lua_pushnil (L);
- msg_info ("cannot parse regexp: %s, error: %s", string, err == NULL ? "undefined" : err->message);
+ msg_info ("cannot parse regexp: %s, error: %s",
+ string,
+ err == NULL ? "undefined" : err->message);
}
else {
new = g_slice_alloc (sizeof (struct rspamd_lua_regexp));
static int
lua_regexp_get_cached (lua_State *L)
{
- struct rspamd_lua_regexp *new, **pnew;
- const gchar *line;
+ struct rspamd_lua_regexp *new, **pnew;
+ const gchar *line;
line = luaL_checkstring (L, 1);
new = re_cache_check (line, regexp_static_pool);
static int
lua_regexp_get_pattern (lua_State *L)
{
- struct rspamd_lua_regexp *re = lua_check_regexp (L);
+ struct rspamd_lua_regexp *re = lua_check_regexp (L);
if (re) {
lua_pushstring (L, re->re_pattern);
static int
lua_regexp_match (lua_State *L)
{
- struct rspamd_lua_regexp *re = lua_check_regexp (L);
- GMatchInfo *mi;
- const gchar *data;
- gchar **matches;
- gint i;
+ struct rspamd_lua_regexp *re = lua_check_regexp (L);
+ GMatchInfo *mi;
+ const gchar *data;
+ gchar **matches;
+ gint i;
if (re) {
data = luaL_checkstring (L, 2);
if (g_regex_match_full (re->re, data, -1, 0, 0, &mi, NULL)) {
matches = g_match_info_fetch_all (mi);
lua_newtable (L);
- for (i = 1; matches[i - 1] != NULL; i ++) {
+ for (i = 1; matches[i - 1] != NULL; i++) {
lua_pushstring (L, matches[i - 1]);
lua_rawseti (L, -2, i);
}
static int
lua_regexp_split (lua_State *L)
{
- struct rspamd_lua_regexp *re = lua_check_regexp (L);
- const gchar *data;
- gchar **parts;
- gint i;
+ struct rspamd_lua_regexp *re = lua_check_regexp (L);
+ const gchar *data;
+ gchar **parts;
+ gint i;
if (re) {
data = luaL_checkstring (L, 2);
}
parts = g_regex_split (re->re, data, 0);
lua_newtable (L);
- for (i = 1; parts[i - 1] != NULL; i ++) {
+ for (i = 1; parts[i - 1] != NULL; i++) {
lua_pushstring (L, parts[i - 1]);
lua_rawseti (L, -2, i);
}
static gint
lua_regexp_destroy (lua_State *L)
{
- struct rspamd_lua_regexp *to_del = lua_check_regexp (L);
+ struct rspamd_lua_regexp *to_del = lua_check_regexp (L);
if (to_del) {
re_cache_del (to_del->re_pattern, regexp_static_pool);
lua_pushstring (L, "rspamd{regexp}");
lua_rawset (L, -3);
- luaL_register (L, NULL, regexplib_m);
+ luaL_register (L, NULL, regexplib_m);
luaL_register (L, "regexp", regexplib_f);
regexp_static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
#ifdef HAVE_OPENSSL
#include <openssl/err.h>
-#include <openssl/sha.h>
-#include <openssl/rsa.h>
#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/sha.h>
-LUA_FUNCTION_DEF (rsa_pubkey, load);
-LUA_FUNCTION_DEF (rsa_pubkey, create);
-LUA_FUNCTION_DEF (rsa_pubkey, gc);
-LUA_FUNCTION_DEF (rsa_privkey, load);
-LUA_FUNCTION_DEF (rsa_privkey, create);
-LUA_FUNCTION_DEF (rsa_privkey, gc);
+LUA_FUNCTION_DEF (rsa_pubkey, load);
+LUA_FUNCTION_DEF (rsa_pubkey, create);
+LUA_FUNCTION_DEF (rsa_pubkey, gc);
+LUA_FUNCTION_DEF (rsa_privkey, load);
+LUA_FUNCTION_DEF (rsa_privkey, create);
+LUA_FUNCTION_DEF (rsa_privkey, gc);
LUA_FUNCTION_DEF (rsa_signature, create);
LUA_FUNCTION_DEF (rsa_signature, load);
LUA_FUNCTION_DEF (rsa_signature, save);
LUA_FUNCTION_DEF (rsa_signature, gc);
-LUA_FUNCTION_DEF (rsa, verify_memory);
-LUA_FUNCTION_DEF (rsa, verify_file);
-LUA_FUNCTION_DEF (rsa, sign_file);
-LUA_FUNCTION_DEF (rsa, sign_memory);
+LUA_FUNCTION_DEF (rsa, verify_memory);
+LUA_FUNCTION_DEF (rsa, verify_file);
+LUA_FUNCTION_DEF (rsa, sign_file);
+LUA_FUNCTION_DEF (rsa, sign_memory);
-static const struct luaL_reg rsalib_f[] = {
+static const struct luaL_reg rsalib_f[] = {
LUA_INTERFACE_DEF (rsa, verify_memory),
LUA_INTERFACE_DEF (rsa, verify_file),
LUA_INTERFACE_DEF (rsa, sign_memory),
};
static const struct luaL_reg rsapubkeylib_f[] = {
- LUA_INTERFACE_DEF (rsa_pubkey, load),
- LUA_INTERFACE_DEF (rsa_pubkey, create),
- {NULL, NULL}
+ LUA_INTERFACE_DEF (rsa_pubkey, load),
+ LUA_INTERFACE_DEF (rsa_pubkey, create),
+ {NULL, NULL}
};
static const struct luaL_reg rsapubkeylib_m[] = {
- {"__tostring", lua_class_tostring},
- {"__gc", lua_rsa_pubkey_gc},
- {NULL, NULL}
+ {"__tostring", lua_class_tostring},
+ {"__gc", lua_rsa_pubkey_gc},
+ {NULL, NULL}
};
static const struct luaL_reg rsaprivkeylib_f[] = {
- LUA_INTERFACE_DEF (rsa_privkey, load),
- LUA_INTERFACE_DEF (rsa_privkey, create),
- {NULL, NULL}
+ LUA_INTERFACE_DEF (rsa_privkey, load),
+ LUA_INTERFACE_DEF (rsa_privkey, create),
+ {NULL, NULL}
};
static const struct luaL_reg rsaprivkeylib_m[] = {
- {"__tostring", lua_class_tostring},
- {"__gc", lua_rsa_privkey_gc},
- {NULL, NULL}
+ {"__tostring", lua_class_tostring},
+ {"__gc", lua_rsa_privkey_gc},
+ {NULL, NULL}
};
static const struct luaL_reg rsasignlib_f[] = {
- LUA_INTERFACE_DEF (rsa_signature, load),
- LUA_INTERFACE_DEF (rsa_signature, create),
- {NULL, NULL}
+ LUA_INTERFACE_DEF (rsa_signature, load),
+ LUA_INTERFACE_DEF (rsa_signature, create),
+ {NULL, NULL}
};
static const struct luaL_reg rsasignlib_m[] = {
- LUA_INTERFACE_DEF (rsa_signature, save),
- {"__tostring", lua_class_tostring},
- {"__gc", lua_rsa_signature_gc},
- {NULL, NULL}
+ LUA_INTERFACE_DEF (rsa_signature, save),
+ {"__tostring", lua_class_tostring},
+ {"__gc", lua_rsa_signature_gc},
+ {NULL, NULL}
};
static RSA *
lua_check_rsa_pubkey (lua_State * L, int pos)
{
- void *ud = luaL_checkudata (L, pos, "rspamd{rsa_pubkey}");
+ void *ud = luaL_checkudata (L, pos, "rspamd{rsa_pubkey}");
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 = luaL_checkudata (L, pos, "rspamd{rsa_privkey}");
+ void *ud = luaL_checkudata (L, pos, "rspamd{rsa_privkey}");
luaL_argcheck (L, ud != NULL, 1, "'rsa_privkey' expected");
return ud ? *((RSA **)ud) : NULL;
static f_str_t *
lua_check_rsa_sign (lua_State * L, int pos)
{
- void *ud = luaL_checkudata (L, pos, "rspamd{rsa_signature}");
+ void *ud = luaL_checkudata (L, pos, "rspamd{rsa_signature}");
luaL_argcheck (L, ud != NULL, 1, "'rsa_signature' expected");
return ud ? *((f_str_t **)ud) : NULL;
static gint
lua_rsa_pubkey_load (lua_State *L)
{
- RSA *rsa = NULL, **prsa;
+ RSA *rsa = NULL, **prsa;
const gchar *filename;
FILE *f;
if (filename != NULL) {
f = fopen (filename, "r");
if (f == NULL) {
- msg_err ("cannot open pubkey from file: %s, %s", filename, strerror (errno));
+ msg_err ("cannot open pubkey from file: %s, %s",
+ filename,
+ strerror (errno));
lua_pushnil (L);
}
else {
- if (! PEM_read_RSA_PUBKEY (f, &rsa, NULL, NULL)) {
+ if (!PEM_read_RSA_PUBKEY (f, &rsa, NULL, NULL)) {
msg_err ("cannot open pubkey from file: %s, %s", filename,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
}
else {
static gint
lua_rsa_pubkey_create (lua_State *L)
{
- RSA *rsa = NULL, **prsa;
+ RSA *rsa = NULL, **prsa;
const gchar *buf;
BIO *bp;
if (buf != NULL) {
bp = BIO_new_mem_buf ((void *)buf, -1);
- if (! PEM_read_bio_RSA_PUBKEY (bp, &rsa, NULL, NULL)) {
+ if (!PEM_read_bio_RSA_PUBKEY (bp, &rsa, NULL, NULL)) {
msg_err ("cannot parse pubkey: %s",
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
}
else {
static gint
lua_rsa_privkey_load (lua_State *L)
{
- RSA *rsa = NULL, **prsa;
+ RSA *rsa = NULL, **prsa;
const gchar *filename;
FILE *f;
if (filename != NULL) {
f = fopen (filename, "r");
if (f == NULL) {
- msg_err ("cannot open private key from file: %s, %s", filename, strerror (errno));
+ msg_err ("cannot open private key from file: %s, %s",
+ filename,
+ strerror (errno));
lua_pushnil (L);
}
else {
- if (! PEM_read_RSAPrivateKey (f, &rsa, NULL, NULL)) {
+ if (!PEM_read_RSAPrivateKey (f, &rsa, NULL, NULL)) {
msg_err ("cannot open private key from file: %s, %s", filename,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
}
else {
static gint
lua_rsa_privkey_create (lua_State *L)
{
- RSA *rsa = NULL, **prsa;
+ RSA *rsa = NULL, **prsa;
const gchar *buf;
BIO *bp;
if (buf != NULL) {
bp = BIO_new_mem_buf ((void *)buf, -1);
- if (! PEM_read_bio_RSAPrivateKey (bp, &rsa, NULL, NULL)) {
+ if (!PEM_read_bio_RSAPrivateKey (bp, &rsa, NULL, NULL)) {
msg_err ("cannot parse private key: %s",
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
}
else {
if (filename != NULL) {
fd = open (filename, O_RDONLY);
if (fd == -1) {
- msg_err ("cannot open signature file: %s, %s", filename, strerror (errno));
+ msg_err ("cannot open signature file: %s, %s", filename,
+ strerror (errno));
lua_pushnil (L);
}
else {
sig = g_malloc (sizeof (f_str_t));
if (fstat (fd, &st) == -1 ||
- (data = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ (data =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
+ 0)) == MAP_FAILED) {
msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
}
fd = open (filename, flags, 00644);
if (fd == -1) {
- msg_err ("cannot create a signature file: %s, %s", filename, strerror (errno));
+ msg_err ("cannot create a signature file: %s, %s",
+ filename,
+ strerror (errno));
lua_pushboolean (L, FALSE);
}
else {
if (errno == EINTR) {
continue;
}
- msg_err ("cannot write to a signature file: %s, %s", filename, strerror (errno));
+ msg_err ("cannot write to a signature file: %s, %s",
+ filename,
+ strerror (errno));
res = FALSE;
break;
}
signature->begin, signature->len, rsa);
if (ret == 0) {
msg_info ("cannot check rsa signature for data: %s",
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushboolean (L, FALSE);
}
else {
}
else {
if (fstat (fd, &st) == -1 ||
- (data = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ (data =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
+ 0)) == MAP_FAILED) {
msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
else {
- data_sig = g_compute_checksum_for_data (G_CHECKSUM_SHA256, data, st.st_size);
+ data_sig = g_compute_checksum_for_data (G_CHECKSUM_SHA256,
+ data,
+ st.st_size);
ret = RSA_verify (NID_sha1, data_sig, strlen (data_sig),
signature->begin, signature->len, rsa);
if (ret == 0) {
msg_info ("cannot check rsa signature for file: %s, %s",
- filename, ERR_error_string (ERR_get_error (), NULL));
+ filename, ERR_error_string (ERR_get_error (), NULL));
lua_pushboolean (L, FALSE);
}
else {
signature->begin, (guint *)&signature->len, rsa);
if (ret == 0) {
msg_info ("cannot make a signature for data: %s",
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
g_free (signature->begin);
g_free (signature);
}
else {
if (fstat (fd, &st) == -1 ||
- (data = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ (data =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
+ 0)) == MAP_FAILED) {
msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
signature->len = RSA_size (rsa);
signature->size = signature->len;
signature->begin = g_malloc (signature->len);
- data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256, data, st.st_size);
+ data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256,
+ data,
+ st.st_size);
ret = RSA_sign (NID_sha1, data_sig, strlen (data_sig),
signature->begin, (guint *)&signature->len, rsa);
if (ret == 0) {
msg_info ("cannot make a signature for data: %s",
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
g_free (signature->begin);
g_free (signature);
lua_pushstring (L, "rspamd{rsa_pubkey}");
lua_rawset (L, -3);
- luaL_register (L, NULL, rsapubkeylib_m);
+ luaL_register (L, NULL, rsapubkeylib_m);
luaL_register (L, "rsa_pubkey", rsapubkeylib_f);
luaL_newmetatable (L, "rspamd{rsa_privkey}");
lua_pushstring (L, "rspamd{rsa_privkey}");
lua_rawset (L, -3);
- luaL_register (L, NULL, rsaprivkeylib_m);
+ luaL_register (L, NULL, rsaprivkeylib_m);
luaL_register (L, "rsa_privkey", rsaprivkeylib_f);
luaL_newmetatable (L, "rspamd{rsa_signature}");
lua_pushstring (L, "rspamd{rsa_signature}");
lua_rawset (L, -3);
- luaL_register (L, NULL, rsasignlib_m);
+ luaL_register (L, NULL, rsasignlib_m);
luaL_register (L, "rsa_signature", rsasignlib_f);
- luaL_register (L, "rsa", rsalib_f);
+ luaL_register (L, "rsa", rsalib_f);
return 1;
}
luaopen_rsa (lua_State * L)
{
msg_info ("this rspamd version is not linked against openssl, therefore no "
- "RSA support is available");
+ "RSA support is available");
return 1;
#include "lua_common.h"
/* Public prototypes */
-struct rspamd_async_session *lua_check_session (lua_State * L);
+struct rspamd_async_session * lua_check_session (lua_State * L);
gint luaopen_session (lua_State * L);
/* Lua bindings */
LUA_FUNCTION_DEF (session, create);
LUA_FUNCTION_DEF (session, delete);
-static const struct luaL_reg sessionlib_m[] = {
+static const struct luaL_reg sessionlib_m[] = {
LUA_INTERFACE_DEF (session, register_async_event),
LUA_INTERFACE_DEF (session, remove_normal_event),
LUA_INTERFACE_DEF (session, check_session_pending),
{NULL, NULL}
};
-static const struct luaL_reg sessionlib_f[] = {
+static const struct luaL_reg sessionlib_f[] = {
LUA_INTERFACE_DEF (session, create),
{NULL, NULL}
};
-static const struct luaL_reg eventlib_m[] = {
+static const struct luaL_reg eventlib_m[] = {
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
struct rspamd_async_session *session;
};
-struct rspamd_async_session *
+struct rspamd_async_session *
lua_check_session (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{session}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{session}");
luaL_argcheck (L, ud != NULL, 1, "'session' expected");
return ud ? *((struct rspamd_async_session **)ud) : NULL;
}
-struct rspamd_async_event *
+struct rspamd_async_event *
lua_check_event (lua_State * L, gint pos)
{
- void *ud = luaL_checkudata (L, pos, "rspamd{event}");
+ void *ud = luaL_checkudata (L, pos, "rspamd{event}");
luaL_argcheck (L, ud != NULL, 1, "'event' expected");
return ud ? *((struct rspamd_async_event **)ud) : NULL;
}
static gboolean
lua_session_finalizer (gpointer ud)
{
- struct lua_session_udata *cbdata = ud;
- gboolean res;
+ struct lua_session_udata *cbdata = ud;
+ gboolean res;
/* Call finalizer function */
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_fin);
if (lua_pcall (cbdata->L, 0, 1, 0) != 0) {
- msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to session finalizer failed: %s",
+ lua_tostring (cbdata->L, -1));
}
res = lua_toboolean (cbdata->L, -1);
lua_pop (cbdata->L, 1);
static void
lua_session_restore (gpointer ud)
{
- struct lua_session_udata *cbdata = ud;
+ struct lua_session_udata *cbdata = ud;
if (cbdata->cbref_restore) {
/* Call restorer function */
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_restore);
if (lua_pcall (cbdata->L, 0, 0, 0) != 0) {
- msg_info ("call to session restorer failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to session restorer failed: %s",
+ lua_tostring (cbdata->L, -1));
}
luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_restore);
}
static void
lua_session_cleanup (gpointer ud)
{
- struct lua_session_udata *cbdata = ud;
+ struct lua_session_udata *cbdata = ud;
if (cbdata->cbref_cleanup) {
/* Call restorer function */
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_cleanup);
if (lua_pcall (cbdata->L, 0, 0, 0) != 0) {
- msg_info ("call to session cleanup failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to session cleanup failed: %s",
+ lua_tostring (cbdata->L, -1));
}
luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_cleanup);
}
static int
lua_session_create (lua_State *L)
{
- struct rspamd_async_session *session, **psession;
- struct lua_session_udata *cbdata;
- rspamd_mempool_t *mempool;
+ struct rspamd_async_session *session, **psession;
+ struct lua_session_udata *cbdata;
+ rspamd_mempool_t *mempool;
cbdata->cbref_cleanup = luaL_ref (L, LUA_REGISTRYINDEX);
}
}
- session = new_async_session (mempool, lua_session_finalizer, lua_session_restore, lua_session_cleanup, cbdata);
+ session = new_async_session (mempool,
+ lua_session_finalizer,
+ lua_session_restore,
+ lua_session_cleanup,
+ cbdata);
cbdata->session = session;
psession = lua_newuserdata (L, sizeof (struct rspamd_async_session *));
lua_setclass (L, "rspamd{session}", -1);
static int
lua_session_delete (lua_State *L)
{
- struct rspamd_async_session *session = lua_check_session (L);
+ struct rspamd_async_session *session = lua_check_session (L);
if (session) {
destroy_session (session);
static void
lua_event_fin (gpointer ud)
{
- struct lua_event_udata *cbdata = ud;
+ struct lua_event_udata *cbdata = ud;
if (cbdata->cbref) {
/* Call restorer function */
lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref);
if (lua_pcall (cbdata->L, 0, 0, 0) != 0) {
- msg_info ("call to event finalizer failed: %s", lua_tostring (cbdata->L, -1));
+ msg_info ("call to event finalizer failed: %s",
+ lua_tostring (cbdata->L, -1));
}
luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref);
}
static int
lua_session_register_async_event (lua_State *L)
{
- struct rspamd_async_session *session = lua_check_session (L);
- struct lua_event_udata *cbdata;
- gpointer *pdata;
+ struct rspamd_async_session *session = lua_check_session (L);
+ struct lua_event_udata *cbdata;
+ gpointer *pdata;
if (session) {
if (lua_isfunction (L, 1)) {
- cbdata = rspamd_mempool_alloc (session->pool, sizeof (struct lua_event_udata));
+ cbdata =
+ rspamd_mempool_alloc (session->pool,
+ sizeof (struct lua_event_udata));
cbdata->L = L;
lua_pushvalue (L, 1);
cbdata->cbref = luaL_ref (L, LUA_REGISTRYINDEX);
cbdata->session = session;
- register_async_event (session, lua_event_fin, cbdata, g_quark_from_static_string ("lua event"));
+ register_async_event (session,
+ lua_event_fin,
+ cbdata,
+ g_quark_from_static_string ("lua event"));
pdata = lua_newuserdata (L, sizeof (gpointer));
lua_setclass (L, "rspamd{event}", -1);
*pdata = cbdata;
static int
lua_session_remove_normal_event (lua_State *L)
{
- struct rspamd_async_session *session = lua_check_session (L);
- gpointer data;
+ struct rspamd_async_session *session = lua_check_session (L);
+ gpointer data;
if (session) {
data = lua_check_event (L, 2);
static int
lua_session_check_session_pending (lua_State *L)
{
- struct rspamd_async_session *session = lua_check_session (L);
+ struct rspamd_async_session *session = lua_check_session (L);
if (session) {
-
+
}
else {
lua_pushnil (L);
lua_pushstring (L, "rspamd{session}");
lua_rawset (L, -3);
- luaL_register (L, NULL, sessionlib_m);
+ luaL_register (L, NULL, sessionlib_m);
luaL_register (L, "rspamd_session", sessionlib_f);
lua_pop (L, 1); /* remove metatable from stack */
lua_pop (L, 1); /* remove metatable from stack */
- return 1;
+ return 1;
}
*/
-#include "lua_common.h"
-#include "message.h"
+#include "binlog.h"
+#include "cfg_file.h"
+#include "classifiers/classifiers.h"
+#include "diff.h"
+#include "dns.h"
#include "expressions.h"
-#include "protocol.h"
#include "filter.h"
-#include "dns.h"
-#include "util.h"
#include "images.h"
-#include "cfg_file.h"
+#include "lua_common.h"
+#include "message.h"
+#include "protocol.h"
#include "statfile.h"
-#include "tokenizers/tokenizers.h"
-#include "classifiers/classifiers.h"
-#include "binlog.h"
#include "statfile_sync.h"
-#include "diff.h"
+#include "tokenizers/tokenizers.h"
+#include "util.h"
-extern stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct rspamd_classifier_config *ccf,
- const gchar *symbol, struct rspamd_statfile_config **st, gboolean try_create);
+extern stat_file_t * get_statfile_by_symbol (statfile_pool_t *pool,
+ struct rspamd_classifier_config *ccf,
+ const gchar *symbol,
+ struct rspamd_statfile_config **st,
+ gboolean try_create);
/* Task creation */
LUA_FUNCTION_DEF (task, create_empty);
LUA_FUNCTION_DEF (task, get_metric_action);
LUA_FUNCTION_DEF (task, learn_statfile);
-static const struct luaL_reg tasklib_f[] = {
+static const struct luaL_reg tasklib_f[] = {
LUA_INTERFACE_DEF (task, create_empty),
LUA_INTERFACE_DEF (task, create_from_buffer),
{NULL, NULL}
};
-static const struct luaL_reg tasklib_m[] = {
+static const struct luaL_reg tasklib_m[] = {
LUA_INTERFACE_DEF (task, get_message),
LUA_INTERFACE_DEF (task, destroy),
LUA_INTERFACE_DEF (task, process_message),
LUA_FUNCTION_DEF (textpart, get_language);
LUA_FUNCTION_DEF (textpart, compare_distance);
-static const struct luaL_reg textpartlib_m[] = {
+static const struct luaL_reg textpartlib_m[] = {
LUA_INTERFACE_DEF (textpart, get_content),
LUA_INTERFACE_DEF (textpart, get_length),
LUA_INTERFACE_DEF (textpart, is_empty),
LUA_FUNCTION_DEF (mimepart, get_type);
LUA_FUNCTION_DEF (mimepart, get_filename);
-static const struct luaL_reg mimepartlib_m[] = {
+static const struct luaL_reg mimepartlib_m[] = {
LUA_INTERFACE_DEF (mimepart, get_content),
LUA_INTERFACE_DEF (mimepart, get_length),
LUA_INTERFACE_DEF (mimepart, get_type),
LUA_FUNCTION_DEF (image, get_filename);
LUA_FUNCTION_DEF (image, get_size);
-static const struct luaL_reg imagelib_m[] = {
+static const struct luaL_reg imagelib_m[] = {
LUA_INTERFACE_DEF (image, get_width),
LUA_INTERFACE_DEF (image, get_height),
LUA_INTERFACE_DEF (image, get_type),
LUA_FUNCTION_DEF (url, is_phished);
LUA_FUNCTION_DEF (url, get_phished);
-static const struct luaL_reg urllib_m[] = {
+static const struct luaL_reg urllib_m[] = {
LUA_INTERFACE_DEF (url, get_length),
LUA_INTERFACE_DEF (url, get_host),
LUA_INTERFACE_DEF (url, get_user),
};
/* Utility functions */
-static struct rspamd_task *
+static struct rspamd_task *
lua_check_task (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{task}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{task}");
luaL_argcheck (L, ud != NULL, 1, "'task' expected");
return ud ? *((struct rspamd_task **)ud) : NULL;
}
-static struct mime_text_part *
+static struct mime_text_part *
lua_check_textpart (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{textpart}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{textpart}");
luaL_argcheck (L, ud != NULL, 1, "'textpart' expected");
return ud ? *((struct mime_text_part **)ud) : NULL;
}
-static struct mime_part *
+static struct mime_part *
lua_check_mimepart (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{mimepart}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{mimepart}");
luaL_argcheck (L, ud != NULL, 1, "'mimepart' expected");
return ud ? *((struct mime_part **)ud) : NULL;
}
-static struct rspamd_image *
+static struct rspamd_image *
lua_check_image (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{image}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{image}");
luaL_argcheck (L, ud != NULL, 1, "'image' expected");
return ud ? *((struct rspamd_image **)ud) : NULL;
}
-static struct uri *
+static struct uri *
lua_check_url (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{url}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{url}");
luaL_argcheck (L, ud != NULL, 1, "'url' expected");
return ud ? *((struct uri **)ud) : NULL;
}
static int
lua_task_create_empty (lua_State *L)
{
- struct rspamd_task **ptask, *task;
+ struct rspamd_task **ptask, *task;
task = rspamd_task_new (NULL);
ptask = lua_newuserdata (L, sizeof (gpointer));
static int
lua_task_create_from_buffer (lua_State *L)
{
- struct rspamd_task **ptask, *task;
- const gchar *data;
- size_t len;
+ struct rspamd_task **ptask, *task;
+ const gchar *data;
+ size_t len;
data = luaL_checklstring (L, 1, &len);
if (data) {
static int
lua_task_process_message (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL && task->msg != NULL && task->msg->len > 0) {
if (process_message (task) == 0) {
static int
lua_task_set_cfg (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- void *ud = luaL_checkudata (L, 2, "rspamd{config}");
+ struct rspamd_task *task = lua_check_task (L);
+ void *ud = luaL_checkudata (L, 2, "rspamd{config}");
luaL_argcheck (L, ud != NULL, 1, "'config' expected");
task->cfg = ud ? *((struct rspamd_config **)ud) : NULL;
static int
lua_task_destroy (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL) {
rspamd_task_free (task, FALSE);
static int
lua_task_get_message (lua_State * L)
{
- GMimeMessage **pmsg;
- struct rspamd_task *task = lua_check_task (L);
+ GMimeMessage **pmsg;
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL && task->message != NULL) {
pmsg = lua_newuserdata (L, sizeof (GMimeMessage *));
static int
lua_task_get_mempool (lua_State * L)
{
- rspamd_mempool_t **ppool;
- struct rspamd_task *task = lua_check_task (L);
+ rspamd_mempool_t **ppool;
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL) {
ppool = lua_newuserdata (L, sizeof (rspamd_mempool_t *));
static int
lua_task_get_session (lua_State * L)
{
- struct rspamd_async_session **psession;
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_async_session **psession;
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL) {
psession = lua_newuserdata (L, sizeof (void *));
static int
lua_task_get_ev_base (lua_State * L)
{
- struct event_base **pbase;
- struct rspamd_task *task = lua_check_task (L);
+ struct event_base **pbase;
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL) {
pbase = lua_newuserdata (L, sizeof (struct event_base *));
static gint
lua_task_insert_result (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *symbol_name, *param;
- double flag;
- GList *params = NULL;
- gint i, top;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *symbol_name, *param;
+ double flag;
+ GList *params = NULL;
+ gint i, top;
if (task != NULL) {
- symbol_name = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
+ symbol_name =
+ rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
flag = luaL_checknumber (L, 3);
top = lua_gettop (L);
/* Get additional options */
for (i = 4; i <= top; i++) {
param = luaL_checkstring (L, i);
- params = g_list_prepend (params, rspamd_mempool_strdup (task->task_pool, param));
+ params =
+ g_list_prepend (params,
+ rspamd_mempool_strdup (task->task_pool, param));
}
insert_result (task, symbol_name, flag, params);
static gint
lua_task_set_pre_result (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
- gchar *action_str;
- guint action;
+ struct rspamd_task *task = lua_check_task (L);
+ gchar *action_str;
+ guint action;
if (task != NULL) {
action = luaL_checkinteger (L, 2);
if (action < task->pre_result.action) {
task->pre_result.action = action;
if (lua_gettop (L) >= 3) {
- action_str = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
+ action_str = rspamd_mempool_strdup (task->task_pool,
+ luaL_checkstring (L, 3));
task->pre_result.str = action_str;
}
else {
}
struct lua_tree_cb_data {
- lua_State *L;
- int i;
+ lua_State *L;
+ int i;
};
static gboolean
lua_tree_url_callback (gpointer key, gpointer value, gpointer ud)
{
- struct uri **purl;
- struct lua_tree_cb_data *cb = ud;
+ struct uri **purl;
+ struct lua_tree_cb_data *cb = ud;
purl = lua_newuserdata (cb->L, sizeof (struct uri *));
lua_setclass (cb->L, "rspamd{url}", -1);
static gint
lua_task_get_urls (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
- struct lua_tree_cb_data cb;
+ struct rspamd_task *task = lua_check_task (L);
+ struct lua_tree_cb_data cb;
if (task) {
lua_newtable (L);
static gint
lua_task_get_emails (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
- struct lua_tree_cb_data cb;
+ struct rspamd_task *task = lua_check_task (L);
+ struct lua_tree_cb_data cb;
if (task) {
lua_newtable (L);
static gint
lua_task_get_text_parts (lua_State * L)
{
- gint i = 1;
- struct rspamd_task *task = lua_check_task (L);
- GList *cur;
- struct mime_text_part *part, **ppart;
+ gint i = 1;
+ struct rspamd_task *task = lua_check_task (L);
+ GList *cur;
+ struct mime_text_part *part, **ppart;
if (task != NULL) {
lua_newtable (L);
static gint
lua_task_get_parts (lua_State * L)
{
- gint i = 1;
- struct rspamd_task *task = lua_check_task (L);
- GList *cur;
- struct mime_part *part, **ppart;
+ gint i = 1;
+ struct rspamd_task *task = lua_check_task (L);
+ GList *cur;
+ struct mime_part *part, **ppart;
if (task != NULL) {
lua_newtable (L);
static gint
lua_task_get_raw_headers (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task) {
lua_pushstring (L, task->raw_headers_str);
static gint
lua_task_get_raw_header_common (lua_State * L, gboolean strong)
{
- struct rspamd_task *task = lua_check_task (L);
- struct raw_header *rh;
- gint i = 1;
- const gchar *name;
+ struct rspamd_task *task = lua_check_task (L);
+ struct raw_header *rh;
+ gint i = 1;
+ const gchar *name;
if (task) {
name = luaL_checkstring (L, 2);
}
/* Create new associated table for a header */
lua_newtable (L);
- lua_set_table_index (L, "name", rh->name);
+ lua_set_table_index (L, "name", rh->name);
lua_set_table_index (L, "value", rh->value);
lua_pushstring (L, "tab_separated");
lua_pushboolean (L, rh->tab_separated);
static gint
lua_task_get_received_headers (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
- GList *cur;
- struct received_header *rh;
- gint i = 1;
+ struct rspamd_task *task = lua_check_task (L);
+ GList *cur;
+ struct received_header *rh;
+ gint i = 1;
if (task) {
lua_newtable (L);
cur = g_list_first (task->received);
while (cur) {
rh = cur->data;
- if (rh->is_error || G_UNLIKELY(
+ if (rh->is_error || G_UNLIKELY (
rh->from_ip == NULL &&
rh->real_ip == NULL &&
rh->real_hostname == NULL &&
static gint
lua_task_get_resolver (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- struct rspamd_dns_resolver **presolver;
+ struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_dns_resolver **presolver;
if (task != NULL && task->resolver != NULL) {
presolver = lua_newuserdata (L, sizeof (void *));
static gint
lua_task_inc_dns_req (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL) {
- task->dns_requests ++;
+ task->dns_requests++;
}
return 0;
static gint
lua_task_call_rspamd_function (lua_State * L)
{
- struct rspamd_task *task = lua_check_task (L);
- struct expression_function f;
- gint i, top;
- gboolean res;
- gchar *arg;
+ struct rspamd_task *task = lua_check_task (L);
+ struct expression_function f;
+ gint i, top;
+ gboolean res;
+ gchar *arg;
if (task) {
f.name = (gchar *)luaL_checkstring (L, 2);
}
return FALSE;
#else
- InternetAddressMailbox *iamb;
+ InternetAddressMailbox *iamb;
if (ia && INTERNET_ADDRESS_IS_MAILBOX (ia)) {
lua_newtable (L);
iamb = INTERNET_ADDRESS_MAILBOX (ia);
lua_set_table_index (L, "name", internet_address_get_name (ia));
- lua_set_table_index (L, "addr", internet_address_mailbox_get_addr (iamb));
+ lua_set_table_index (L, "addr",
+ internet_address_mailbox_get_addr (iamb));
return TRUE;
}
return FALSE;
static void
lua_push_internet_address_list (lua_State *L, InternetAddressList *addrs)
{
- InternetAddress *ia;
- gint idx = 1;
+ InternetAddress *ia;
+ gint idx = 1;
#ifndef GMIME24
/* Gmime 2.2 version */
- InternetAddressList *cur;
+ InternetAddressList *cur;
lua_newtable (L);
cur = addrs;
}
#else
/* Gmime 2.4 version */
- gsize len, i;
+ gsize len, i;
lua_newtable (L);
if (addrs != NULL) {
len = internet_address_list_length (addrs);
- for (i = 0; i < len; i ++) {
+ for (i = 0; i < len; i++) {
ia = internet_address_list_get_address (addrs, i);
if (lua_push_internet_address (L, ia)) {
lua_rawseti (L, -2, idx++);
static gint
lua_task_get_recipients (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- GList *cur;
- InternetAddressList *addrs;
- gint idx = 1;
+ struct rspamd_task *task = lua_check_task (L);
+ GList *cur;
+ InternetAddressList *addrs;
+ gint idx = 1;
if (task) {
cur = task->rcpt;
#ifndef GMIME24
addrs = internet_address_parse_string (cur->data);
if (addrs) {
- if (lua_push_internet_address (L, internet_address_list_get_address (addrs))) {
+ if (lua_push_internet_address (L,
+ internet_address_list_get_address (addrs))) {
lua_rawseti (L, -2, idx++);
}
internet_address_list_destroy (addrs);
addrs = internet_address_list_parse_string (cur->data);
if (addrs) {
- if (lua_push_internet_address (L, internet_address_list_get_address (addrs, 0))) {
+ if (lua_push_internet_address (L,
+ internet_address_list_get_address (addrs, 0))) {
lua_rawseti (L, -2, idx++);
}
g_object_unref (addrs);
static gint
lua_task_get_from (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- InternetAddressList *addrs;
-
+ struct rspamd_task *task = lua_check_task (L);
+ InternetAddressList *addrs;
+
if (task) {
if (task->from != NULL) {
#ifndef GMIME24
#endif
if (addrs != NULL) {
lua_push_internet_address_list (L, addrs);
-#ifndef GMIME24
+#ifndef GMIME24
internet_address_list_destroy (addrs);
#else
g_object_unref (addrs);
static gint
lua_task_set_from (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *new_from;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *new_from;
if (task) {
new_from = luaL_checkstring (L, 2);
static gint
lua_task_get_user (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task && task->user != NULL) {
lua_pushstring (L, task->user);
static gint
lua_task_set_user (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *new_user;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *new_user;
if (task) {
new_user = luaL_checkstring (L, 2);
static gint
lua_task_get_recipients_headers (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task && task->rcpts) {
lua_push_internet_address_list (L, task->rcpts);
static gint
lua_task_get_from_headers (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- InternetAddressList *addrs;
+ struct rspamd_task *task = lua_check_task (L);
+ InternetAddressList *addrs;
if (task && task->message != NULL) {
#ifndef GMIME24
- addrs = internet_address_parse_string (g_mime_message_get_sender (task->message));
+ addrs =
+ internet_address_parse_string (g_mime_message_get_sender (
+ task->message));
#else
- addrs = internet_address_list_parse_string (g_mime_message_get_sender (task->message));
+ addrs =
+ internet_address_list_parse_string (g_mime_message_get_sender (task
+ ->message));
#endif
if (addrs) {
lua_push_internet_address_list (L, addrs);
-#ifndef GMIME24
+#ifndef GMIME24
internet_address_list_destroy (addrs);
#else
g_object_unref (addrs);
static gint
lua_task_get_from_ip (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
-
+ struct rspamd_task *task = lua_check_task (L);
+
if (task) {
lua_ip_push (L, &task->from_addr);
}
static gint
lua_task_get_client_ip_num (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
-
+ struct rspamd_task *task = lua_check_task (L);
+
if (task) {
lua_ip_push (L, &task->client_addr);
}
static gint
lua_task_get_helo (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
-
+ struct rspamd_task *task = lua_check_task (L);
+
if (task) {
if (task->helo != NULL) {
lua_pushstring (L, (gchar *)task->helo);
static gint
lua_task_set_helo (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *new_helo;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *new_helo;
if (task) {
new_helo = luaL_checkstring (L, 2);
static gint
lua_task_get_hostname (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task) {
if (task->hostname != NULL) {
static gint
lua_task_set_hostname (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *new_hostname;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *new_hostname;
if (task) {
new_hostname = luaL_checkstring (L, 2);
if (new_hostname) {
- task->hostname = rspamd_mempool_strdup (task->task_pool, new_hostname);
+ task->hostname = rspamd_mempool_strdup (task->task_pool,
+ new_hostname);
}
}
static gint
lua_task_get_images (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- gint i = 1;
- GList *cur;
- struct rspamd_image **pimg;
+ struct rspamd_task *task = lua_check_task (L);
+ gint i = 1;
+ GList *cur;
+ struct rspamd_image **pimg;
if (task) {
cur = task->images;
}
static inline gboolean
-lua_push_symbol_result (lua_State *L, struct rspamd_task *task, struct metric *metric, const gchar *symbol)
+lua_push_symbol_result (lua_State *L,
+ struct rspamd_task *task,
+ struct metric *metric,
+ const gchar *symbol)
{
- struct metric_result *metric_res;
- struct symbol *s;
- gint j;
- GList *opt;
+ struct metric_result *metric_res;
+ struct symbol *s;
+ gint j;
+ GList *opt;
metric_res = g_hash_table_lookup (task->results, metric->name);
if (metric_res) {
static gint
lua_task_get_symbol (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *symbol;
- struct metric *metric;
- GList *cur = NULL, *metric_list;
- gboolean found = FALSE;
- gint i = 1;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *symbol;
+ struct metric *metric;
+ GList *cur = NULL, *metric_list;
+ gboolean found = FALSE;
+ gint i = 1;
symbol = luaL_checkstring (L, 2);
static gint
lua_task_get_date (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- time_t task_time;
+ struct rspamd_task *task = lua_check_task (L);
+ time_t task_time;
if (task != NULL) {
/* Get GMT date and store it to time_t */
static gint
lua_task_get_message_id (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL && task->message_id != NULL) {
lua_pushstring (L, task->message_id);
static gint
lua_task_get_timeval (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
+ struct rspamd_task *task = lua_check_task (L);
if (task != NULL) {
lua_newtable (L);
static gint
lua_task_learn_statfile (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *symbol;
- struct rspamd_classifier_config *cl;
- GTree *tokens;
- struct rspamd_statfile_config *st;
- stat_file_t *statfile;
- struct classifier_ctx *ctx;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *symbol;
+ struct rspamd_classifier_config *cl;
+ GTree *tokens;
+ struct rspamd_statfile_config *st;
+ stat_file_t *statfile;
+ struct classifier_ctx *ctx;
symbol = luaL_checkstring (L, 2);
return 1;
}
ctx = cl->classifier->init_func (task->task_pool, cl);
- if ((tokens = g_hash_table_lookup (task->tokens, cl->tokenizer)) == NULL) {
+ if ((tokens =
+ g_hash_table_lookup (task->tokens, cl->tokenizer)) == NULL) {
msg_warn ("no tokens found learn failed!");
lua_pushboolean (L, FALSE);
return 1;
}
- statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool, ctx->cfg,
- symbol, &st, TRUE);
+ statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool,
+ ctx->cfg,
+ symbol,
+ &st,
+ TRUE);
if (statfile == NULL) {
msg_warn ("opening statfile failed!");
return 1;
}
- cl->classifier->learn_func (ctx, task->worker->srv->statfile_pool, symbol, tokens, TRUE, NULL, 1., NULL);
+ cl->classifier->learn_func (ctx,
+ task->worker->srv->statfile_pool,
+ symbol,
+ tokens,
+ TRUE,
+ NULL,
+ 1.,
+ NULL);
maybe_write_binlog (ctx->cfg, st, statfile, tokens);
lua_pushboolean (L, TRUE);
}
static gint
lua_task_get_metric_score (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *metric_name;
- struct metric_result *metric_res;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *metric_name;
+ struct metric_result *metric_res;
metric_name = luaL_checkstring (L, 2);
if (task && metric_name) {
- if ((metric_res = g_hash_table_lookup (task->results, metric_name)) != NULL) {
+ if ((metric_res =
+ g_hash_table_lookup (task->results, metric_name)) != NULL) {
lua_newtable (L);
lua_pushnumber (L, metric_res->score);
lua_rawseti (L, -2, 1);
- lua_pushnumber (L, metric_res->metric->actions[METRIC_ACTION_REJECT].score);
+ lua_pushnumber (L,
+ metric_res->metric->actions[METRIC_ACTION_REJECT].score);
lua_rawseti (L, -2, 2);
- lua_pushnumber (L, metric_res->metric->actions[METRIC_ACTION_REJECT].score);
+ lua_pushnumber (L,
+ metric_res->metric->actions[METRIC_ACTION_REJECT].score);
lua_rawseti (L, -2, 3);
}
else {
static gint
lua_task_get_metric_action (lua_State *L)
{
- struct rspamd_task *task = lua_check_task (L);
- const gchar *metric_name;
- struct metric_result *metric_res;
- enum rspamd_metric_action action;
+ struct rspamd_task *task = lua_check_task (L);
+ const gchar *metric_name;
+ struct metric_result *metric_res;
+ enum rspamd_metric_action action;
metric_name = luaL_checkstring (L, 2);
if (task && metric_name) {
- if ((metric_res = g_hash_table_lookup (task->results, metric_name)) != NULL) {
+ if ((metric_res =
+ g_hash_table_lookup (task->results, metric_name)) != NULL) {
action = check_metric_action (metric_res->score,
- metric_res->metric->actions[METRIC_ACTION_REJECT].score, metric_res->metric);
+ metric_res->metric->actions[METRIC_ACTION_REJECT].score,
+ metric_res->metric);
lua_pushstring (L, str_action_metric (action));
}
else {
static gint
lua_textpart_get_content (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L);
+ struct mime_text_part *part = lua_check_textpart (L);
if (part == NULL || part->is_empty) {
lua_pushnil (L);
static gint
lua_textpart_get_length (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L);
+ struct mime_text_part *part = lua_check_textpart (L);
if (part == NULL) {
lua_pushnil (L);
static gint
lua_textpart_is_empty (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L);
+ struct mime_text_part *part = lua_check_textpart (L);
if (part == NULL) {
lua_pushnil (L);
static gint
lua_textpart_is_html (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L);
+ struct mime_text_part *part = lua_check_textpart (L);
if (part == NULL) {
lua_pushnil (L);
static gint
lua_textpart_get_fuzzy (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L);
+ struct mime_text_part *part = lua_check_textpart (L);
if (part == NULL || part->is_empty) {
lua_pushnil (L);
return 1;
}
- lua_pushlstring (L, part->fuzzy->hash_pipe, sizeof (part->fuzzy->hash_pipe));
+ lua_pushlstring (L, part->fuzzy->hash_pipe,
+ sizeof (part->fuzzy->hash_pipe));
return 1;
}
static gint
lua_textpart_get_language (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L);
- static const gchar languages[][4] = {
- "", /* G_UNICODE_SCRIPT_COMMON */
- "", /* G_UNICODE_SCRIPT_INHERITED */
- "ar", /* G_UNICODE_SCRIPT_ARABIC */
- "hy", /* G_UNICODE_SCRIPT_ARMENIAN */
- "bn", /* G_UNICODE_SCRIPT_BENGALI */
- /* Used primarily in Taiwan, but not part of the standard
- * zh-tw orthography */
- "", /* G_UNICODE_SCRIPT_BOPOMOFO */
- "chr", /* G_UNICODE_SCRIPT_CHEROKEE */
- "cop", /* G_UNICODE_SCRIPT_COPTIC */
- "ru", /* G_UNICODE_SCRIPT_CYRILLIC */
- /* Deseret was used to write English */
- "", /* G_UNICODE_SCRIPT_DESERET */
- "hi", /* G_UNICODE_SCRIPT_DEVANAGARI */
- "am", /* G_UNICODE_SCRIPT_ETHIOPIC */
- "ka", /* G_UNICODE_SCRIPT_GEORGIAN */
- "", /* G_UNICODE_SCRIPT_GOTHIC */
- "el", /* G_UNICODE_SCRIPT_GREEK */
- "gu", /* G_UNICODE_SCRIPT_GUJARATI */
- "pa", /* G_UNICODE_SCRIPT_GURMUKHI */
- "", /* G_UNICODE_SCRIPT_HAN */
- "ko", /* G_UNICODE_SCRIPT_HANGUL */
- "he", /* G_UNICODE_SCRIPT_HEBREW */
- "ja", /* G_UNICODE_SCRIPT_HIRAGANA */
- "kn", /* G_UNICODE_SCRIPT_KANNADA */
- "ja", /* G_UNICODE_SCRIPT_KATAKANA */
- "km", /* G_UNICODE_SCRIPT_KHMER */
- "lo", /* G_UNICODE_SCRIPT_LAO */
- "en", /* G_UNICODE_SCRIPT_LATIN */
- "ml", /* G_UNICODE_SCRIPT_MALAYALAM */
- "mn", /* G_UNICODE_SCRIPT_MONGOLIAN */
- "my", /* G_UNICODE_SCRIPT_MYANMAR */
- /* Ogham was used to write old Irish */
- "", /* G_UNICODE_SCRIPT_OGHAM */
- "", /* G_UNICODE_SCRIPT_OLD_ITALIC */
- "or", /* G_UNICODE_SCRIPT_ORIYA */
- "", /* G_UNICODE_SCRIPT_RUNIC */
- "si", /* G_UNICODE_SCRIPT_SINHALA */
- "syr", /* G_UNICODE_SCRIPT_SYRIAC */
- "ta", /* G_UNICODE_SCRIPT_TAMIL */
- "te", /* G_UNICODE_SCRIPT_TELUGU */
- "dv", /* G_UNICODE_SCRIPT_THAANA */
- "th", /* G_UNICODE_SCRIPT_THAI */
- "bo", /* G_UNICODE_SCRIPT_TIBETAN */
- "iu", /* G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL */
- "", /* G_UNICODE_SCRIPT_YI */
- "tl", /* G_UNICODE_SCRIPT_TAGALOG */
- /* Phillipino languages/scripts */
- "hnn", /* G_UNICODE_SCRIPT_HANUNOO */
- "bku", /* G_UNICODE_SCRIPT_BUHID */
- "tbw", /* G_UNICODE_SCRIPT_TAGBANWA */
-
- "", /* G_UNICODE_SCRIPT_BRAILLE */
- "", /* G_UNICODE_SCRIPT_CYPRIOT */
- "", /* G_UNICODE_SCRIPT_LIMBU */
- /* Used for Somali (so) in the past */
- "", /* G_UNICODE_SCRIPT_OSMANYA */
- /* The Shavian alphabet was designed for English */
- "", /* G_UNICODE_SCRIPT_SHAVIAN */
- "", /* G_UNICODE_SCRIPT_LINEAR_B */
- "", /* G_UNICODE_SCRIPT_TAI_LE */
- "uga", /* G_UNICODE_SCRIPT_UGARITIC */
-
- "", /* G_UNICODE_SCRIPT_NEW_TAI_LUE */
- "bug", /* G_UNICODE_SCRIPT_BUGINESE */
- /* The original script for Old Church Slavonic (chu), later
- * written with Cyrillic */
- "", /* G_UNICODE_SCRIPT_GLAGOLITIC */
- /* Used for for Berber (ber), but Arabic script is more common */
- "", /* G_UNICODE_SCRIPT_TIFINAGH */
- "syl", /* G_UNICODE_SCRIPT_SYLOTI_NAGRI */
- "peo", /* G_UNICODE_SCRIPT_OLD_PERSIAN */
- "", /* G_UNICODE_SCRIPT_KHAROSHTHI */
-
- "", /* G_UNICODE_SCRIPT_UNKNOWN */
- "", /* G_UNICODE_SCRIPT_BALINESE */
- "", /* G_UNICODE_SCRIPT_CUNEIFORM */
- "", /* G_UNICODE_SCRIPT_PHOENICIAN */
- "", /* G_UNICODE_SCRIPT_PHAGS_PA */
- "nqo" /* G_UNICODE_SCRIPT_NKO */
+ struct mime_text_part *part = lua_check_textpart (L);
+ static const gchar languages[][4] = {
+ "", /* G_UNICODE_SCRIPT_COMMON */
+ "", /* G_UNICODE_SCRIPT_INHERITED */
+ "ar", /* G_UNICODE_SCRIPT_ARABIC */
+ "hy", /* G_UNICODE_SCRIPT_ARMENIAN */
+ "bn", /* G_UNICODE_SCRIPT_BENGALI */
+ /* Used primarily in Taiwan, but not part of the standard
+ * zh-tw orthography */
+ "", /* G_UNICODE_SCRIPT_BOPOMOFO */
+ "chr", /* G_UNICODE_SCRIPT_CHEROKEE */
+ "cop", /* G_UNICODE_SCRIPT_COPTIC */
+ "ru", /* G_UNICODE_SCRIPT_CYRILLIC */
+ /* Deseret was used to write English */
+ "", /* G_UNICODE_SCRIPT_DESERET */
+ "hi", /* G_UNICODE_SCRIPT_DEVANAGARI */
+ "am", /* G_UNICODE_SCRIPT_ETHIOPIC */
+ "ka", /* G_UNICODE_SCRIPT_GEORGIAN */
+ "", /* G_UNICODE_SCRIPT_GOTHIC */
+ "el", /* G_UNICODE_SCRIPT_GREEK */
+ "gu", /* G_UNICODE_SCRIPT_GUJARATI */
+ "pa", /* G_UNICODE_SCRIPT_GURMUKHI */
+ "", /* G_UNICODE_SCRIPT_HAN */
+ "ko", /* G_UNICODE_SCRIPT_HANGUL */
+ "he", /* G_UNICODE_SCRIPT_HEBREW */
+ "ja", /* G_UNICODE_SCRIPT_HIRAGANA */
+ "kn", /* G_UNICODE_SCRIPT_KANNADA */
+ "ja", /* G_UNICODE_SCRIPT_KATAKANA */
+ "km", /* G_UNICODE_SCRIPT_KHMER */
+ "lo", /* G_UNICODE_SCRIPT_LAO */
+ "en", /* G_UNICODE_SCRIPT_LATIN */
+ "ml", /* G_UNICODE_SCRIPT_MALAYALAM */
+ "mn", /* G_UNICODE_SCRIPT_MONGOLIAN */
+ "my", /* G_UNICODE_SCRIPT_MYANMAR */
+ /* Ogham was used to write old Irish */
+ "", /* G_UNICODE_SCRIPT_OGHAM */
+ "", /* G_UNICODE_SCRIPT_OLD_ITALIC */
+ "or", /* G_UNICODE_SCRIPT_ORIYA */
+ "", /* G_UNICODE_SCRIPT_RUNIC */
+ "si", /* G_UNICODE_SCRIPT_SINHALA */
+ "syr", /* G_UNICODE_SCRIPT_SYRIAC */
+ "ta", /* G_UNICODE_SCRIPT_TAMIL */
+ "te", /* G_UNICODE_SCRIPT_TELUGU */
+ "dv", /* G_UNICODE_SCRIPT_THAANA */
+ "th", /* G_UNICODE_SCRIPT_THAI */
+ "bo", /* G_UNICODE_SCRIPT_TIBETAN */
+ "iu", /* G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL */
+ "", /* G_UNICODE_SCRIPT_YI */
+ "tl", /* G_UNICODE_SCRIPT_TAGALOG */
+ /* Phillipino languages/scripts */
+ "hnn", /* G_UNICODE_SCRIPT_HANUNOO */
+ "bku", /* G_UNICODE_SCRIPT_BUHID */
+ "tbw", /* G_UNICODE_SCRIPT_TAGBANWA */
+
+ "", /* G_UNICODE_SCRIPT_BRAILLE */
+ "", /* G_UNICODE_SCRIPT_CYPRIOT */
+ "", /* G_UNICODE_SCRIPT_LIMBU */
+ /* Used for Somali (so) in the past */
+ "", /* G_UNICODE_SCRIPT_OSMANYA */
+ /* The Shavian alphabet was designed for English */
+ "", /* G_UNICODE_SCRIPT_SHAVIAN */
+ "", /* G_UNICODE_SCRIPT_LINEAR_B */
+ "", /* G_UNICODE_SCRIPT_TAI_LE */
+ "uga", /* G_UNICODE_SCRIPT_UGARITIC */
+
+ "", /* G_UNICODE_SCRIPT_NEW_TAI_LUE */
+ "bug", /* G_UNICODE_SCRIPT_BUGINESE */
+ /* The original script for Old Church Slavonic (chu), later
+ * written with Cyrillic */
+ "", /* G_UNICODE_SCRIPT_GLAGOLITIC */
+ /* Used for for Berber (ber), but Arabic script is more common */
+ "", /* G_UNICODE_SCRIPT_TIFINAGH */
+ "syl", /* G_UNICODE_SCRIPT_SYLOTI_NAGRI */
+ "peo", /* G_UNICODE_SCRIPT_OLD_PERSIAN */
+ "", /* G_UNICODE_SCRIPT_KHAROSHTHI */
+
+ "", /* G_UNICODE_SCRIPT_UNKNOWN */
+ "", /* G_UNICODE_SCRIPT_BALINESE */
+ "", /* G_UNICODE_SCRIPT_CUNEIFORM */
+ "", /* G_UNICODE_SCRIPT_PHOENICIAN */
+ "", /* G_UNICODE_SCRIPT_PHAGS_PA */
+ "nqo" /* G_UNICODE_SCRIPT_NKO */
};
- const gchar *sel;
+ const gchar *sel;
- if (part != NULL && part->script > 0 && part->script < (gint)G_N_ELEMENTS (languages)) {
+ if (part != NULL && part->script > 0 && part->script <
+ (gint)G_N_ELEMENTS (languages)) {
sel = languages[part->script];
if (*sel != '\0') {
lua_pushstring (L, sel);
static gint
lua_textpart_compare_distance (lua_State * L)
{
- struct mime_text_part *part = lua_check_textpart (L), *other;
- void *ud = luaL_checkudata (L, 2, "rspamd{textpart}");
- gint diff = -1;
- GMimeObject *parent;
- const GMimeContentType *ct;
+ struct mime_text_part *part = lua_check_textpart (L), *other;
+ void *ud = luaL_checkudata (L, 2, "rspamd{textpart}");
+ gint diff = -1;
+ GMimeObject *parent;
+ const GMimeContentType *ct;
luaL_argcheck (L, ud != NULL, 2, "'textpart' expected");
other = ud ? *((struct mime_text_part **)ud) : NULL;
parent = part->parent;
ct = g_mime_object_get_content_type (parent);
#ifndef GMIME24
- if (ct == NULL || ! g_mime_content_type_is_type (ct, "multipart", "alternative")) {
+ if (ct == NULL ||
+ !g_mime_content_type_is_type (ct, "multipart", "alternative")) {
#else
- if (ct == NULL || ! g_mime_content_type_is_type ((GMimeContentType *)ct, "multipart", "alternative")) {
+ if (ct == NULL ||
+ !g_mime_content_type_is_type ((GMimeContentType *)ct, "multipart",
+ "alternative")) {
#endif
diff = -1;
else {
if (!part->is_empty && !other->is_empty) {
if (part->diff_str != NULL && other->diff_str != NULL) {
- diff = compare_diff_distance (part->diff_str, other->diff_str);
+ diff = compare_diff_distance (part->diff_str,
+ other->diff_str);
}
else {
diff = fuzzy_compare_parts (part, other);
}
}
- else if ((part->is_empty && !other->is_empty) || (!part->is_empty && other->is_empty)) {
+ else if ((part->is_empty &&
+ !other->is_empty) || (!part->is_empty && other->is_empty)) {
/* Empty and non empty parts are different */
diff = 0;
}
}
}
else {
- diff = -1;
+ diff = -1;
}
static gint
lua_mimepart_get_content (lua_State * L)
{
- struct mime_part *part = lua_check_mimepart (L);
+ struct mime_part *part = lua_check_mimepart (L);
if (part == NULL) {
lua_pushnil (L);
static gint
lua_mimepart_get_length (lua_State * L)
{
- struct mime_part *part = lua_check_mimepart (L);
+ struct mime_part *part = lua_check_mimepart (L);
if (part == NULL) {
lua_pushnil (L);
static gint
lua_mimepart_get_type (lua_State * L)
{
- struct mime_part *part = lua_check_mimepart (L);
+ struct mime_part *part = lua_check_mimepart (L);
if (part == NULL) {
lua_pushnil (L);
static gint
lua_mimepart_get_filename (lua_State * L)
{
- struct mime_part *part = lua_check_mimepart (L);
+ struct mime_part *part = lua_check_mimepart (L);
if (part == NULL || part->filename == NULL) {
lua_pushnil (L);
static gint
lua_image_get_width (lua_State *L)
{
- struct rspamd_image *img = lua_check_image (L);
+ struct rspamd_image *img = lua_check_image (L);
if (img != NULL) {
lua_pushnumber (L, img->width);
static gint
lua_image_get_height (lua_State *L)
{
- struct rspamd_image *img = lua_check_image (L);
+ struct rspamd_image *img = lua_check_image (L);
if (img != NULL) {
lua_pushnumber (L, img->height);
static gint
lua_image_get_type (lua_State *L)
{
- struct rspamd_image *img = lua_check_image (L);
+ struct rspamd_image *img = lua_check_image (L);
if (img != NULL) {
lua_pushstring (L, image_type_str (img->type));
static gint
lua_image_get_size (lua_State *L)
{
- struct rspamd_image *img = lua_check_image (L);
+ struct rspamd_image *img = lua_check_image (L);
if (img != NULL) {
lua_pushinteger (L, img->data->len);
static gint
lua_image_get_filename (lua_State *L)
{
- struct rspamd_image *img = lua_check_image (L);
+ struct rspamd_image *img = lua_check_image (L);
if (img != NULL && img->filename != NULL) {
lua_pushstring (L, img->filename);
static gint
lua_url_get_length (lua_State *L)
{
- struct uri *url = lua_check_url (L);
+ struct uri *url = lua_check_url (L);
if (url != NULL) {
lua_pushinteger (L, strlen (struri (url)));
static gint
lua_url_get_host (lua_State *L)
{
- struct uri *url = lua_check_url (L);
+ struct uri *url = lua_check_url (L);
if (url != NULL) {
lua_pushlstring (L, url->host, url->hostlen);
static gint
lua_url_get_user (lua_State *L)
{
- struct uri *url = lua_check_url (L);
+ struct uri *url = lua_check_url (L);
if (url != NULL) {
lua_pushlstring (L, url->user, url->userlen);
static gint
lua_url_get_path (lua_State *L)
{
- struct uri *url = lua_check_url (L);
+ struct uri *url = lua_check_url (L);
if (url != NULL) {
lua_pushlstring (L, url->data, url->datalen);
static gint
lua_url_get_text (lua_State *L)
{
- struct uri *url = lua_check_url (L);
+ struct uri *url = lua_check_url (L);
if (url != NULL) {
lua_pushstring (L, struri (url));
static gint
lua_url_is_phished (lua_State *L)
{
- struct uri *url = lua_check_url (L);
+ struct uri *url = lua_check_url (L);
if (url != NULL) {
lua_pushboolean (L, url->is_phished);
static gint
lua_url_get_phished (lua_State *L)
{
- struct uri **purl, *url = lua_check_url (L);
+ struct uri **purl, *url = lua_check_url (L);
if (url) {
if (url->is_phished && url->phished_url != NULL) {
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "cfg_file.h"
#include "config.h"
#include "lua_common.h"
#include "upstream.h"
-#include "cfg_file.h"
/* Upstream timeouts */
#define DEFAULT_UPSTREAM_ERROR_TIME 10
LUA_FUNCTION_DEF (upstream_list, get_upstream_round_robin);
LUA_FUNCTION_DEF (upstream_list, get_upstream_master_slave);
-static const struct luaL_reg upstream_list_m[] = {
+static const struct luaL_reg upstream_list_m[] = {
LUA_INTERFACE_DEF (upstream_list, get_upstream_by_hash),
LUA_INTERFACE_DEF (upstream_list, get_upstream_round_robin),
{"__gc", lua_upstream_list_destroy},
{NULL, NULL}
};
-static const struct luaL_reg upstream_list_f[] = {
+static const struct luaL_reg upstream_list_f[] = {
LUA_INTERFACE_DEF (upstream_list, create),
{NULL, NULL}
};
LUA_FUNCTION_DEF (upstream, get_ip_string);
LUA_FUNCTION_DEF (upstream, get_priority);
-static const struct luaL_reg upstream_m[] = {
+static const struct luaL_reg upstream_m[] = {
LUA_INTERFACE_DEF (upstream, ok),
LUA_INTERFACE_DEF (upstream, fail),
LUA_INTERFACE_DEF (upstream, get_ip),
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
-static const struct luaL_reg upstream_f[] = {
+static const struct luaL_reg upstream_f[] = {
LUA_INTERFACE_DEF (upstream, create),
{NULL, NULL}
};
gchar *addr;
};
-static struct lua_upstream *
+static struct lua_upstream *
lua_check_upstream (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{upstream}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{upstream}");
luaL_argcheck (L, ud != NULL, 1, "'upstream' expected");
return ud ? *((struct lua_upstream **)ud) : NULL;
static gint
lua_upstream_create (lua_State *L)
{
- struct lua_upstream *new, **pnew;
- const gchar *def;
+ struct lua_upstream *new, **pnew;
+ const gchar *def;
def = luaL_checkstring (L, 1);
if (def) {
new = g_slice_alloc0 (sizeof (struct lua_upstream));
new->def = g_strdup (def);
new->addr = g_malloc (INET6_ADDRSTRLEN);
- if (!rspamd_parse_host_port_priority (NULL, new->def, &new->addr, &new->port, &new->up.priority)) {
+ if (!rspamd_parse_host_port_priority (NULL, new->def, &new->addr,
+ &new->port, &new->up.priority)) {
g_free (new->def);
g_slice_free1 (sizeof (struct lua_upstream), new);
lua_pushnil (L);
static gint
lua_upstream_destroy (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
+ struct lua_upstream *up = lua_check_upstream (L);
if (up) {
g_free (up->def);
static gint
lua_upstream_get_ip (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
+ struct lua_upstream *up = lua_check_upstream (L);
if (up) {
lua_pushstring (L, up->addr);
static gint
lua_upstream_get_ip_string (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
+ struct lua_upstream *up = lua_check_upstream (L);
if (up) {
lua_pushstring (L, up->addr);
static gint
lua_upstream_get_port (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
+ struct lua_upstream *up = lua_check_upstream (L);
if (up) {
lua_pushinteger (L, up->port);
static gint
lua_upstream_get_priority (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
+ struct lua_upstream *up = lua_check_upstream (L);
if (up) {
lua_pushinteger (L, up->up.priority);
static gint
lua_upstream_fail (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
- time_t now;
+ struct lua_upstream *up = lua_check_upstream (L);
+ time_t now;
if (up) {
if (lua_gettop (L) >= 2) {
static gint
lua_upstream_ok (lua_State *L)
{
- struct lua_upstream *up = lua_check_upstream (L);
- time_t now;
+ struct lua_upstream *up = lua_check_upstream (L);
+ time_t now;
if (up) {
if (lua_gettop (L) >= 2) {
guint count;
};
-static struct lua_upstream_list *
+static struct lua_upstream_list *
lua_check_upstream_list (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{upstream_list}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{upstream_list}");
luaL_argcheck (L, ud != NULL, 1, "'upstream_list' expected");
return ud ? *((struct lua_upstream_list **)ud) : NULL;
static gint
lua_upstream_list_create (lua_State *L)
{
- struct lua_upstream_list *new, **pnew;
- struct lua_upstream *cur;
- const gchar *def;
- char **tokens;
- guint i, default_port = 0;
+ struct lua_upstream_list *new, **pnew;
+ struct lua_upstream *cur;
+ const gchar *def;
+ char **tokens;
+ guint i, default_port = 0;
def = luaL_checkstring (L, 1);
if (def) {
goto err;
}
new->count = g_strv_length (tokens);
- new->upstreams = g_slice_alloc0 (new->count * sizeof (struct lua_upstream));
+ new->upstreams =
+ g_slice_alloc0 (new->count * sizeof (struct lua_upstream));
- for (i = 0; i < new->count; i ++) {
+ for (i = 0; i < new->count; i++) {
cur = &new->upstreams[i];
cur->addr = g_malloc (INET6_ADDRSTRLEN);
- if (!rspamd_parse_host_port_priority (NULL, tokens[i], &cur->addr, &cur->port, &cur->up.priority)) {
+ if (!rspamd_parse_host_port_priority (NULL, tokens[i], &cur->addr,
+ &cur->port, &cur->up.priority)) {
goto err;
}
if (cur->port == 0) {
g_strfreev (tokens);
}
if (new->upstreams) {
- for (i = 0; i < new->count; i ++) {
+ for (i = 0; i < new->count; i++) {
cur = &new->upstreams[i];
if (cur->addr) {
g_free (cur->addr);
}
}
- g_slice_free1 (new->count * sizeof (struct lua_upstream), new->upstreams);
+ g_slice_free1 (new->count * sizeof (struct lua_upstream),
+ new->upstreams);
}
g_slice_free1 (sizeof (struct lua_upstream_list), new);
lua_pushnil (L);
static gint
lua_upstream_list_destroy (lua_State *L)
{
- struct lua_upstream_list *upl = lua_check_upstream_list (L);
- struct lua_upstream *cur;
- guint i;
+ struct lua_upstream_list *upl = lua_check_upstream_list (L);
+ struct lua_upstream *cur;
+ guint i;
if (upl) {
if (upl->upstreams) {
- for (i = 0; i < upl->count; i ++) {
+ for (i = 0; i < upl->count; i++) {
cur = &upl->upstreams[i];
if (cur->addr) {
g_free (cur->addr);
}
}
- g_slice_free1 (upl->count * sizeof (struct lua_upstream), upl->upstreams);
+ g_slice_free1 (upl->count * sizeof (struct lua_upstream),
+ upl->upstreams);
}
g_slice_free1 (sizeof (struct lua_upstream_list), upl);
}
static gint
lua_upstream_list_get_upstream_by_hash (lua_State *L)
{
- struct lua_upstream_list *upl;
- struct lua_upstream *selected, **pselected;
- time_t now;
- const gchar *key;
+ struct lua_upstream_list *upl;
+ struct lua_upstream *selected, **pselected;
+ time_t now;
+ const gchar *key;
upl = lua_check_upstream_list (L);
if (upl) {
else {
now = time (NULL);
}
- selected = (struct lua_upstream *)get_upstream_by_hash (upl->upstreams, upl->count,
- sizeof (struct lua_upstream), now,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
- key, 0);
+ selected = (struct lua_upstream *)get_upstream_by_hash (
+ upl->upstreams,
+ upl->count,
+ sizeof (struct lua_upstream),
+ now,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS,
+ key,
+ 0);
if (selected) {
pselected = lua_newuserdata (L, sizeof (struct lua_upstream *));
lua_setclass (L, "rspamd{upstream}", -1);
static gint
lua_upstream_list_get_upstream_round_robin (lua_State *L)
{
- struct lua_upstream_list *upl;
- struct lua_upstream *selected, **pselected;
- time_t now;
+ struct lua_upstream_list *upl;
+ struct lua_upstream *selected, **pselected;
+ time_t now;
upl = lua_check_upstream_list (L);
if (upl) {
else {
now = time (NULL);
}
- selected = (struct lua_upstream *)get_upstream_round_robin (upl->upstreams, upl->count,
- sizeof (struct lua_upstream), now,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
+ selected = (struct lua_upstream *)get_upstream_round_robin (
+ upl->upstreams,
+ upl->count,
+ sizeof (struct lua_upstream),
+ now,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS);
if (selected) {
pselected = lua_newuserdata (L, sizeof (struct lua_upstream *));
lua_setclass (L, "rspamd{upstream}", -1);
static gint
lua_upstream_list_get_upstream_master_slave (lua_State *L)
{
- struct lua_upstream_list *upl;
- struct lua_upstream *selected, **pselected;
- time_t now;
+ struct lua_upstream_list *upl;
+ struct lua_upstream *selected, **pselected;
+ time_t now;
upl = lua_check_upstream_list (L);
if (upl) {
else {
now = time (NULL);
}
- selected = (struct lua_upstream *)get_upstream_master_slave (upl->upstreams, upl->count,
- sizeof (struct lua_upstream), now,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
+ selected = (struct lua_upstream *)get_upstream_master_slave (
+ upl->upstreams,
+ upl->count,
+ sizeof (struct lua_upstream),
+ now,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS);
if (selected) {
pselected = lua_newuserdata (L, sizeof (struct lua_upstream *));
lua_setclass (L, "rspamd{upstream}", -1);
lua_pushstring (L, "rspamd{upstream_list}");
lua_rawset (L, -3);
- luaL_register (L, NULL, upstream_list_m);
+ luaL_register (L, NULL, upstream_list_m);
luaL_register (L, "upstream_list", upstream_list_f);
lua_pop (L, 1); /* remove metatable from stack */
lua_pushstring (L, "rspamd{upstream}");
lua_rawset (L, -3);
- luaL_register (L, NULL, upstream_m);
+ luaL_register (L, NULL, upstream_m);
luaL_register (L, "upstream", upstream_f);
lua_pop (L, 1); /* remove metatable from stack */
LUA_FUNCTION_DEF (xmlrpc, parse_reply);
LUA_FUNCTION_DEF (xmlrpc, make_request);
-static const struct luaL_reg xmlrpclib_m[] = {
+static const struct luaL_reg xmlrpclib_m[] = {
LUA_INTERFACE_DEF (xmlrpc, parse_reply),
LUA_INTERFACE_DEF (xmlrpc, make_request),
{"__tostring", lua_class_tostring},
lua_State *L;
};
-static void xmlrpc_start_element (GMarkupParseContext *context, const gchar *name, const gchar **attribute_names,
- const gchar **attribute_values, gpointer user_data, GError **error);
-static void xmlrpc_end_element (GMarkupParseContext *context, const gchar *element_name, gpointer user_data,
- GError **error);
-static void xmlrpc_error (GMarkupParseContext *context, GError *error, gpointer user_data);
-static void xmlrpc_text (GMarkupParseContext *context, const gchar *text, gsize text_len, gpointer user_data,
- GError **error);
+static void xmlrpc_start_element (GMarkupParseContext *context,
+ const gchar *name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error);
+static void xmlrpc_end_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data,
+ GError **error);
+static void xmlrpc_error (GMarkupParseContext *context,
+ GError *error,
+ gpointer user_data);
+static void xmlrpc_text (GMarkupParseContext *context,
+ const gchar *text,
+ gsize text_len,
+ gpointer user_data,
+ GError **error);
static GMarkupParser xmlrpc_parser = {
.start_element = xmlrpc_start_element,
}
static void
-xmlrpc_start_element (GMarkupParseContext *context, const gchar *name, const gchar **attribute_names,
- const gchar **attribute_values, gpointer user_data, GError **error)
+xmlrpc_start_element (GMarkupParseContext *context,
+ const gchar *name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error)
{
- struct lua_xmlrpc_ud *ud = user_data;
- int last_state;
+ struct lua_xmlrpc_ud *ud = user_data;
+ int last_state;
last_state = ud->parser_state;
ud->parser_state = 5;
/* Create new param of table type */
lua_newtable (ud->L);
- ud->depth ++;
+ ud->depth++;
}
else if (g_ascii_strcasecmp (name, "string") == 0) {
ud->parser_state = 11;
ud->parser_state = 5;
/* Create new param of table type */
lua_newtable (ud->L);
- ud->depth ++;
+ ud->depth++;
}
else {
/* Error state */
}
if (ud->parser_state == 99) {
- g_set_error (error, xmlrpc_error_quark(), 1, "xmlrpc parse error on state: %d, while parsing start tag: %s",
- last_state, name);
+ g_set_error (error,
+ xmlrpc_error_quark (), 1, "xmlrpc parse error on state: %d, while parsing start tag: %s",
+ last_state, name);
}
}
static void
-xmlrpc_end_element (GMarkupParseContext *context, const gchar *name, gpointer user_data, GError **error)
+xmlrpc_end_element (GMarkupParseContext *context,
+ const gchar *name,
+ gpointer user_data,
+ GError **error)
{
- struct lua_xmlrpc_ud *ud = user_data;
- int last_state;
+ struct lua_xmlrpc_ud *ud = user_data;
+ int last_state;
last_state = ud->parser_state;
/* Got tag struct */
if (g_ascii_strcasecmp (name, "struct") == 0) {
ud->parser_state = 4;
- ud->depth --;
+ ud->depth--;
}
else {
/* Error state */
}
if (ud->parser_state == 99) {
- g_set_error (error, xmlrpc_error_quark(), 1, "xmlrpc parse error on state: %d, while parsing end tag: %s",
- last_state, name);
+ g_set_error (error,
+ xmlrpc_error_quark (), 1, "xmlrpc parse error on state: %d, while parsing end tag: %s",
+ last_state, name);
}
}
static void
-xmlrpc_text (GMarkupParseContext *context, const gchar *text, gsize text_len, gpointer user_data, GError **error)
+xmlrpc_text (GMarkupParseContext *context,
+ const gchar *text,
+ gsize text_len,
+ gpointer user_data,
+ GError **error)
{
- struct lua_xmlrpc_ud *ud = user_data;
- gint num;
- gdouble dnum;
+ struct lua_xmlrpc_ud *ud = user_data;
+ gint num;
+ gdouble dnum;
/* Strip line */
while (text_len > 0 && g_ascii_isspace (*text)) {
- text ++;
- text_len --;
+ text++;
+ text_len--;
}
while (text_len > 0 && g_ascii_isspace (text[text_len - 1])) {
- text_len --;
+ text_len--;
}
if (text_len > 0) {
static void
xmlrpc_error (GMarkupParseContext *context, GError *error, gpointer user_data)
{
- struct lua_xmlrpc_ud *ud = user_data;
+ struct lua_xmlrpc_ud *ud = user_data;
msg_err ("xmlrpc parser error: %s", error->message, ud->parser_state);
}
static gint
lua_xmlrpc_parse_reply (lua_State *L)
{
- const gchar *data;
- GMarkupParseContext *ctx;
- GError *err = NULL;
- struct lua_xmlrpc_ud ud;
- gsize s;
- gboolean res;
+ const gchar *data;
+ GMarkupParseContext *ctx;
+ GError *err = NULL;
+ struct lua_xmlrpc_ud ud;
+ gsize s;
+ gboolean res;
data = luaL_checklstring (L, 1, &s);
res = g_markup_parse_context_parse (ctx, data, s, &err);
g_markup_parse_context_free (ctx);
- if (! res) {
+ if (!res) {
lua_pushnil (L);
}
}
}
static gint
-lua_xmlrpc_parse_table (lua_State *L, gint pos, gchar *databuf, gint pr, gsize size)
+lua_xmlrpc_parse_table (lua_State *L,
+ gint pos,
+ gchar *databuf,
+ gint pr,
+ gsize size)
{
- gint r = pr, num;
- double dnum;
+ gint r = pr, num;
+ double dnum;
r += rspamd_snprintf (databuf + r, size - r, "<struct>");
lua_pushnil (L); /* first key */
/* uses 'key' (at index -2) and 'value' (at index -1) */
if (lua_type (L, -2) != LUA_TSTRING) {
/* Ignore non sting keys */
- lua_pop(L, 1);
+ lua_pop (L, 1);
continue;
}
- r += rspamd_snprintf (databuf + r, size - r, "<member><name>%s</name><value>",
+ r += rspamd_snprintf (databuf + r,
+ size - r,
+ "<member><name>%s</name><value>",
lua_tostring (L, -2));
switch (lua_type (L, -1)) {
case LUA_TNUMBER:
/* Try to avoid conversion errors */
if (dnum != (double)num) {
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<double>%f</double>",
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<double>%f</double>",
dnum);
}
else {
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<int>%d</int>",
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<int>%d</int>",
num);
}
break;
case LUA_TBOOLEAN:
- r += rspamd_snprintf (databuf + r, size - r, "<boolean>%d</boolean>",
+ r += rspamd_snprintf (databuf + r,
+ size - r,
+ "<boolean>%d</boolean>",
lua_toboolean (L, -1) ? 1 : 0);
break;
case LUA_TSTRING:
}
r += rspamd_snprintf (databuf + r, size - r, "</value></member>");
/* removes 'value'; keeps 'key' for next iteration */
- lua_pop(L, 1);
+ lua_pop (L, 1);
}
r += rspamd_snprintf (databuf + r, size - r, "</struct>");
static gint
lua_xmlrpc_make_request (lua_State *L)
{
- gchar databuf[BUFSIZ * 2];
- const gchar *func;
- gint r, top, i, num;
- double dnum;
+ gchar databuf[BUFSIZ * 2];
+ const gchar *func;
+ gint r, top, i, num;
+ double dnum;
func = luaL_checkstring (L, 1);
top = lua_gettop (L);
/* Get additional options */
for (i = 2; i <= top; i++) {
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<param><value>");
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<param><value>");
switch (lua_type (L, i)) {
case LUA_TNUMBER:
num = lua_tointeger (L, i);
/* Try to avoid conversion errors */
if (dnum != (double)num) {
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<double>%f</double>",
- dnum);
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<double>%f</double>",
+ dnum);
}
else {
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<int>%d</int>",
- num);
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<int>%d</int>",
+ num);
}
break;
case LUA_TBOOLEAN:
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<boolean>%d</boolean>",
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<boolean>%d</boolean>",
lua_toboolean (L, i) ? 1 : 0);
break;
case LUA_TSTRING:
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<string>%s</string>",
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "<string>%s</string>",
lua_tostring (L, i));
break;
case LUA_TTABLE:
- r += lua_xmlrpc_parse_table (L, i, databuf, r, sizeof (databuf));
+ r +=
+ lua_xmlrpc_parse_table (L, i, databuf, r, sizeof (databuf));
break;
}
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "</value></param>");
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "</value></param>");
}
- r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "</params></methodCall>");
+ r += rspamd_snprintf (databuf + r,
+ sizeof (databuf) - r,
+ "</params></methodCall>");
lua_pushlstring (L, databuf, r);
}
else {
*/
+#include "cfg_file.h"
#include "config.h"
-#include "util.h"
+#include "dns.h"
#include "main.h"
+#include "map.h"
+#include "message.h"
#include "protocol.h"
#include "upstream.h"
-#include "cfg_file.h"
#include "url.h"
-#include "message.h"
-#include "map.h"
-#include "dns.h"
+#include "util.h"
#include "lua/lua_common.h"
void start_lua_worker (struct rspamd_worker *worker);
worker_t lua_worker = {
- "lua", /* Name */
- init_lua_worker, /* Init function */
- start_lua_worker, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE, /* Killable */
- SOCK_STREAM /* TCP socket */
+ "lua", /* Name */
+ init_lua_worker, /* Init function */
+ start_lua_worker, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE, /* Killable */
+ SOCK_STREAM /* TCP socket */
};
/*
*/
struct rspamd_lua_worker_ctx {
/* DNS resolver */
- struct rspamd_dns_resolver *resolver;
+ struct rspamd_dns_resolver *resolver;
/* Events base */
- struct event_base *ev_base;
+ struct event_base *ev_base;
/* Other params */
- GHashTable *params;
+ GHashTable *params;
/* Lua script to load */
- gchar *file;
+ gchar *file;
/* Lua state */
- lua_State *L;
+ lua_State *L;
/* Callback for accept */
- gint cbref_accept;
+ gint cbref_accept;
/* Callback for finishing */
- gint cbref_fin;
+ gint cbref_fin;
/* Config file */
- struct rspamd_config *cfg;
+ struct rspamd_config *cfg;
/* The rest options */
- ucl_object_t *opts;
+ ucl_object_t *opts;
};
/* Lua bindings */
LUA_FUNCTION_DEF (worker, get_resolver);
LUA_FUNCTION_DEF (worker, get_cfg);
-static const struct luaL_reg lua_workerlib_m[] = {
+static const struct luaL_reg lua_workerlib_m[] = {
LUA_INTERFACE_DEF (worker, get_ev_base),
LUA_INTERFACE_DEF (worker, register_accept_callback),
LUA_INTERFACE_DEF (worker, register_exit_callback),
return 1;
}
-struct rspamd_lua_worker_ctx *
+struct rspamd_lua_worker_ctx *
lua_check_lua_worker (lua_State * L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{worker}");
+ void *ud = luaL_checkudata (L, 1, "rspamd{worker}");
luaL_argcheck (L, ud != NULL, 1, "'worker' expected");
return ud ? *((struct rspamd_lua_worker_ctx **)ud) : NULL;
}
static int
lua_worker_get_ev_base (lua_State *L)
{
- struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
- struct event_base **pbase;
+ struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+ struct event_base **pbase;
if (ctx) {
pbase = lua_newuserdata (L, sizeof (struct event_base *));
static int
lua_worker_register_accept_callback (lua_State *L)
{
- struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+ struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
if (ctx) {
if (!lua_isfunction (L, 2)) {
static int
lua_worker_register_exit_callback (lua_State *L)
{
- struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+ struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
if (ctx) {
if (!lua_isfunction (L, 2)) {
static int
lua_worker_get_option (lua_State *L)
{
- struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
- const ucl_object_t *val;
- const gchar *name;
+ struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+ const ucl_object_t *val;
+ const gchar *name;
if (ctx) {
name = luaL_checkstring (L, 2);
static int
lua_worker_get_resolver (lua_State *L)
{
- struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
- struct rspamd_dns_resolver **presolver;
+ struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+ struct rspamd_dns_resolver **presolver;
if (ctx) {
presolver = lua_newuserdata (L, sizeof (gpointer));
static int
lua_worker_get_cfg (lua_State *L)
{
- struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
- struct rspamd_config **pcfg;
+ struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+ struct rspamd_config **pcfg;
if (ctx) {
pcfg = lua_newuserdata (L, sizeof (gpointer));
static void
lua_accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *) arg;
- struct rspamd_lua_worker_ctx *ctx, **pctx;
- gint nfd;
- lua_State *L;
- rspamd_inet_addr_t addr;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_lua_worker_ctx *ctx, **pctx;
+ gint nfd;
+ lua_State *L;
+ rspamd_inet_addr_t addr;
ctx = worker->ctx;
L = ctx->L;
if ((nfd =
- rspamd_accept_from_socket (fd, &addr)) == -1) {
+ rspamd_accept_from_socket (fd, &addr)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
}
msg_info ("accepted connection from %s port %d",
- rspamd_inet_address_to_string (&addr),
- rspamd_inet_address_get_port (&addr));
+ rspamd_inet_address_to_string (&addr),
+ rspamd_inet_address_get_port (&addr));
/* Call finalizer function */
lua_rawgeti (L, LUA_REGISTRYINDEX, ctx->cbref_accept);
static gboolean
rspamd_lua_worker_parser (ucl_object_t *obj, gpointer ud)
{
- struct rspamd_lua_worker_ctx *ctx = ud;
+ struct rspamd_lua_worker_ctx *ctx = ud;
ctx->opts = obj;
gpointer
init_lua_worker (struct rspamd_config *cfg)
{
- struct rspamd_lua_worker_ctx *ctx;
- GQuark type;
+ struct rspamd_lua_worker_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("lua");
ctx = g_malloc0 (sizeof (struct rspamd_lua_worker_ctx));
- ctx->params = g_hash_table_new_full (rspamd_str_hash, rspamd_str_equal, g_free, (GDestroyNotify)g_list_free);
+ ctx->params = g_hash_table_new_full (rspamd_str_hash,
+ rspamd_str_equal,
+ g_free,
+ (GDestroyNotify)g_list_free);
rspamd_rcl_register_worker_option (cfg, type, "file",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct rspamd_lua_worker_ctx, file), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct rspamd_lua_worker_ctx, file), 0);
- rspamd_rcl_register_worker_parser (cfg, type, rspamd_lua_worker_parser, ctx);
+ rspamd_rcl_register_worker_parser (cfg, type, rspamd_lua_worker_parser,
+ ctx);
return ctx;
}
void
start_lua_worker (struct rspamd_worker *worker)
{
- struct rspamd_lua_worker_ctx *ctx = worker->ctx, **pctx;
- lua_State *L;
+ struct rspamd_lua_worker_ctx *ctx = worker->ctx, **pctx;
+ lua_State *L;
#ifdef WITH_PROFILER
- extern void _start (void), etext (void);
+ extern void _start (void), etext (void);
monstartup ((u_long) & _start, (u_long) & etext);
#endif
- ctx->ev_base = rspamd_prepare_worker (worker, "lua_worker", lua_accept_socket);
+ ctx->ev_base = rspamd_prepare_worker (worker,
+ "lua_worker",
+ lua_accept_socket);
L = worker->srv->cfg->lua_state;
ctx->L = L;
ctx->cfg = worker->srv->cfg;
- ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
+ ctx->resolver = dns_resolver_init (worker->srv->logger,
+ ctx->ev_base,
+ worker->srv->cfg);
/* Open worker's lib */
luaopen_lua_worker (L);
exit (EXIT_SUCCESS);
}
if (access (ctx->file, R_OK) == -1) {
- msg_err ("Error reading lua script %s: %s", ctx->file, strerror (errno));
+ msg_err ("Error reading lua script %s: %s", ctx->file,
+ strerror (errno));
exit (EXIT_SUCCESS);
}
*pctx = ctx;
if (luaL_dofile (L, ctx->file) != 0) {
- msg_err ("Error executing lua script %s: %s", ctx->file, lua_tostring (L, -1));
+ msg_err ("Error executing lua script %s: %s", ctx->file,
+ lua_tostring (L, -1));
exit (EXIT_SUCCESS);
}
lua_setclass (L, "rspamd{worker}", -1);
*pctx = ctx;
if (lua_pcall (L, 1, 0, 0) != 0) {
- msg_info ("call to worker finalizer failed: %s", lua_tostring (L, -1));
+ msg_info ("call to worker finalizer failed: %s", lua_tostring (L,
+ -1));
}
/* Free resources */
luaL_unref (L, LUA_REGISTRYINDEX, ctx->cbref_fin);
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
-#include "main.h"
#include "cfg_file.h"
-#include "util.h"
-#include "lmtp.h"
-#include "smtp.h"
-#include "map.h"
+#include "config.h"
#include "fuzzy_storage.h"
#include "kvstorage_server.h"
-#include "symbols_cache.h"
+#include "lmtp.h"
#include "lua/lua_common.h"
+#include "main.h"
+#include "map.h"
#include "ottery.h"
+#include "smtp.h"
+#include "symbols_cache.h"
+#include "util.h"
#ifdef HAVE_OPENSSL
-#include <openssl/rand.h>
#include <openssl/err.h>
#include <openssl/evp.h>
-#include <openssl/rsa.h>
#include <openssl/pem.h>
+#include <openssl/rand.h>
+#include <openssl/rsa.h>
#endif
#ifdef HAVE_LOCALE_H
#include <locale.h>
/* 10 seconds after getting termination signal to terminate all workers with SIGKILL */
#define HARD_TERMINATION_TIME 10
-static struct rspamd_worker *fork_worker (struct rspamd_main *, struct rspamd_worker_conf *);
-static gboolean load_rspamd_config (struct rspamd_config *cfg, gboolean init_modules);
-static void init_cfg_cache (struct rspamd_config *cfg);
+static struct rspamd_worker * fork_worker (struct rspamd_main *,
+ struct rspamd_worker_conf *);
+static gboolean load_rspamd_config (struct rspamd_config *cfg,
+ gboolean init_modules);
+static void init_cfg_cache (struct rspamd_config *cfg);
-sig_atomic_t do_restart = 0;
-sig_atomic_t do_reopen_log = 0;
-sig_atomic_t do_terminate = 0;
-sig_atomic_t child_dead = 0;
-sig_atomic_t got_alarm = 0;
+sig_atomic_t do_restart = 0;
+sig_atomic_t do_reopen_log = 0;
+sig_atomic_t do_terminate = 0;
+sig_atomic_t child_dead = 0;
+sig_atomic_t got_alarm = 0;
#ifdef HAVE_SA_SIGINFO
-GQueue *signals_info = NULL;
+GQueue *signals_info = NULL;
#endif
-static gboolean config_test = FALSE;
-static gboolean no_fork = FALSE;
-static gchar **cfg_names = NULL;
-static gchar **lua_tests = NULL;
-static gchar **sign_configs = NULL;
-static gchar *privkey = NULL;
-static gchar *rspamd_user = NULL;
-static gchar *rspamd_group = NULL;
-static gchar *rspamd_pidfile = NULL;
-static gboolean dump_cache = FALSE;
-static gboolean is_debug = FALSE;
-static gboolean is_insecure = FALSE;
+static gboolean config_test = FALSE;
+static gboolean no_fork = FALSE;
+static gchar **cfg_names = NULL;
+static gchar **lua_tests = NULL;
+static gchar **sign_configs = NULL;
+static gchar *privkey = NULL;
+static gchar *rspamd_user = NULL;
+static gchar *rspamd_group = NULL;
+static gchar *rspamd_pidfile = NULL;
+static gboolean dump_cache = FALSE;
+static gboolean is_debug = FALSE;
+static gboolean is_insecure = FALSE;
/* List of workers that are pending to start */
-static GList *workers_pending = NULL;
+static GList *workers_pending = NULL;
/* List of unrelated forked processes */
-static GArray *other_workers = NULL;
+static GArray *other_workers = NULL;
/* List of active listen sockets indexed by worker type */
-static GHashTable *listen_sockets = NULL;
+static GHashTable *listen_sockets = NULL;
-struct rspamd_main *rspamd_main;
+struct rspamd_main *rspamd_main;
/* Commandline options */
-static GOptionEntry entries[] =
+static GOptionEntry entries[] =
{
- { "config-test", 't', 0, G_OPTION_ARG_NONE, &config_test, "Do config test and exit", NULL },
- { "no-fork", 'f', 0, G_OPTION_ARG_NONE, &no_fork, "Do not daemonize main process", NULL },
- { "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &cfg_names, "Specify config file(s)", NULL },
- { "user", 'u', 0, G_OPTION_ARG_STRING, &rspamd_user, "User to run rspamd as", NULL },
- { "group", 'g', 0, G_OPTION_ARG_STRING, &rspamd_group, "Group to run rspamd as", NULL },
- { "pid", 'p', 0, G_OPTION_ARG_STRING, &rspamd_pidfile, "Path to pidfile", NULL },
- { "dump-cache", 'C', 0, G_OPTION_ARG_NONE, &dump_cache, "Dump symbols cache stats and exit", NULL },
- { "debug", 'd', 0, G_OPTION_ARG_NONE, &is_debug, "Force debug output", NULL },
- { "insecure", 'i', 0, G_OPTION_ARG_NONE, &is_insecure, "Ignore running workers as privileged users (insecure)", NULL },
- { "test-lua", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &lua_tests, "Specify lua file(s) to test", NULL },
- { "sign-config", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &sign_configs, "Specify config file(s) to sign", NULL },
- { "private-key", 0, 0, G_OPTION_ARG_FILENAME, &privkey, "Specify private key to sign", NULL },
- { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
+ { "config-test", 't', 0, G_OPTION_ARG_NONE, &config_test,
+ "Do config test and exit", NULL },
+ { "no-fork", 'f', 0, G_OPTION_ARG_NONE, &no_fork,
+ "Do not daemonize main process", NULL },
+ { "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &cfg_names,
+ "Specify config file(s)", NULL },
+ { "user", 'u', 0, G_OPTION_ARG_STRING, &rspamd_user,
+ "User to run rspamd as", NULL },
+ { "group", 'g', 0, G_OPTION_ARG_STRING, &rspamd_group,
+ "Group to run rspamd as", NULL },
+ { "pid", 'p', 0, G_OPTION_ARG_STRING, &rspamd_pidfile, "Path to pidfile",
+ NULL },
+ { "dump-cache", 'C', 0, G_OPTION_ARG_NONE, &dump_cache,
+ "Dump symbols cache stats and exit", NULL },
+ { "debug", 'd', 0, G_OPTION_ARG_NONE, &is_debug, "Force debug output",
+ NULL },
+ { "insecure", 'i', 0, G_OPTION_ARG_NONE, &is_insecure,
+ "Ignore running workers as privileged users (insecure)", NULL },
+ { "test-lua", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &lua_tests,
+ "Specify lua file(s) to test", NULL },
+ { "sign-config", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &sign_configs,
+ "Specify config file(s) to sign", NULL },
+ { "private-key", 0, 0, G_OPTION_ARG_FILENAME, &privkey,
+ "Specify private key to sign", NULL },
+ { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
chldsigcode (gint code) {
switch (code) {
#ifdef CLD_EXITED
- case CLD_EXITED:
- return "Child exited normally";
- case CLD_KILLED:
- return "Child has terminated abnormally but did not create a core file";
- case CLD_DUMPED:
- return "Child has terminated abnormally and created a core file";
- case CLD_TRAPPED:
- return "Traced child has trapped";
+ case CLD_EXITED:
+ return "Child exited normally";
+ case CLD_KILLED:
+ return "Child has terminated abnormally but did not create a core file";
+ case CLD_DUMPED:
+ return "Child has terminated abnormally and created a core file";
+ case CLD_TRAPPED:
+ return "Traced child has trapped";
#endif
- default:
- return "Unknown reason";
+ default:
+ return "Unknown reason";
}
}
while ((inf = g_queue_pop_head (signals_info))) {
if (inf->si_signo == SIGCHLD) {
msg_info ("got SIGCHLD from child: %P; reason: '%s'",
- inf->si_pid, chldsigcode (inf->si_code));
+ inf->si_pid, chldsigcode (inf->si_code));
}
else {
msg_info ("got signal: '%s'; received from pid: %P; uid: %ul",
- g_strsignal (inf->si_signo), inf->si_pid, (gulong)inf->si_uid);
+ g_strsignal (inf->si_signo), inf->si_pid, (gulong)inf->si_uid);
}
g_free (inf);
}
static void
read_cmd_line (gint argc, gchar **argv, struct rspamd_config *cfg)
{
- GError *error = NULL;
- GOptionContext *context;
- guint i, cfg_num;
- pid_t r;
+ GError *error = NULL;
+ GOptionContext *context;
+ guint i, cfg_num;
+ pid_t r;
context = g_option_context_new ("- run rspamd daemon");
- g_option_context_set_summary (context, "Summary:\n Rspamd daemon version " RVERSION "\n Release id: " RID);
+ g_option_context_set_summary (context,
+ "Summary:\n Rspamd daemon version " RVERSION "\n Release id: " RID);
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
fprintf (stderr, "option parsing failed: %s\n", error->message);
else {
cfg->cfg_name = cfg_names[0];
}
- for (i = 1; i < cfg_num; i ++) {
+ for (i = 1; i < cfg_num; i++) {
r = fork ();
if (r == 0) {
/* Spawning new main process */
(void)setsid ();
}
else if (r == -1) {
- fprintf (stderr, "fork failed while spawning process for %s configuration file: %s\n", cfg_names[i], strerror (errno));
+ fprintf (stderr,
+ "fork failed while spawning process for %s configuration file: %s\n",
+ cfg_names[i],
+ strerror (errno));
}
else {
/* Save pid to the list of other main processes, we need it to ignore SIGCHLD from them */
static void
detect_priv (struct rspamd_main *rspamd)
{
- struct passwd *pwd;
- struct group *grp;
- uid_t euid;
+ struct passwd *pwd;
+ struct group *grp;
+ uid_t euid;
euid = geteuid ();
if (euid == 0) {
if (!rspamd->cfg->rspamd_user && !is_insecure) {
- msg_err ("cannot run rspamd workers as root user, please add -u and -g options to select a proper unprivilleged user or specify --insecure flag");
+ msg_err (
+ "cannot run rspamd workers as root user, please add -u and -g options to select a proper unprivilleged user or specify --insecure flag");
exit (EXIT_FAILURE);
}
else if (is_insecure) {
rspamd->is_privilleged = TRUE;
pwd = getpwnam (rspamd->cfg->rspamd_user);
if (pwd == NULL) {
- msg_err ("user specified does not exists (%s), aborting", strerror (errno));
+ msg_err ("user specified does not exists (%s), aborting",
+ strerror (errno));
exit (-errno);
}
if (rspamd->cfg->rspamd_group) {
grp = getgrnam (rspamd->cfg->rspamd_group);
if (grp == NULL) {
- msg_err ("group specified does not exists (%s), aborting", strerror (errno));
+ msg_err ("group specified does not exists (%s), aborting",
+ strerror (errno));
exit (-errno);
}
rspamd->workers_gid = grp->gr_gid;
{
if (rspamd->is_privilleged) {
if (setgid (rspamd->workers_gid) == -1) {
- msg_err ("cannot setgid to %d (%s), aborting", (gint)rspamd->workers_gid, strerror (errno));
+ msg_err ("cannot setgid to %d (%s), aborting",
+ (gint)rspamd->workers_gid,
+ strerror (errno));
exit (-errno);
}
if (rspamd->cfg->rspamd_user &&
- initgroups (rspamd->cfg->rspamd_user, rspamd->workers_gid) == -1) {
+ initgroups (rspamd->cfg->rspamd_user, rspamd->workers_gid) == -1) {
msg_err ("initgroups failed (%s), aborting", strerror (errno));
exit (-errno);
}
if (setuid (rspamd->workers_uid) == -1) {
- msg_err ("cannot setuid to %d (%s), aborting", (gint)rspamd->workers_uid, strerror (errno));
+ msg_err ("cannot setuid to %d (%s), aborting",
+ (gint)rspamd->workers_uid,
+ strerror (errno));
exit (-errno);
}
}
static void
parse_filters_str (struct rspamd_config *cfg, const gchar *str)
{
- gchar **strvec, **p;
- struct filter *cur;
- module_t **pmodule;
+ gchar **strvec, **p;
+ struct filter *cur;
+ module_t **pmodule;
if (str == NULL) {
return;
pmodule = &modules[0];
while (*pmodule) {
g_strstrip (*p);
- if ((*pmodule)->name != NULL && g_ascii_strcasecmp ((*pmodule)->name, *p) == 0) {
- cur = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct filter));
+ if ((*pmodule)->name != NULL &&
+ g_ascii_strcasecmp ((*pmodule)->name, *p) == 0) {
+ cur = rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct filter));
cur->type = C_FILTER;
msg_debug ("found C filter %s", *p);
cur->func_name = rspamd_mempool_strdup (cfg->cfg_pool, *p);
break;
}
- pmodule ++;
+ pmodule++;
}
if (cur != NULL) {
/* Go to next iteration */
static void
reread_config (struct rspamd_main *rspamd)
{
- struct rspamd_config *tmp_cfg;
- gchar *cfg_file;
- GList *l;
- struct filter *filt;
+ struct rspamd_config *tmp_cfg;
+ gchar *cfg_file;
+ GList *l;
+ struct filter *filt;
tmp_cfg = (struct rspamd_config *)g_malloc (sizeof (struct rspamd_config));
if (tmp_cfg) {
bzero (tmp_cfg, sizeof (struct rspamd_config));
tmp_cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
rspamd_config_defaults (tmp_cfg);
- cfg_file = rspamd_mempool_strdup (tmp_cfg->cfg_pool, rspamd->cfg->cfg_name);
+ cfg_file = rspamd_mempool_strdup (tmp_cfg->cfg_pool,
+ rspamd->cfg->cfg_name);
/* Save some variables */
tmp_cfg->cfg_name = cfg_file;
tmp_cfg->lua_state = init_lua (tmp_cfg);
- rspamd_mempool_add_destructor (tmp_cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_close, tmp_cfg->lua_state);
+ rspamd_mempool_add_destructor (tmp_cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_close, tmp_cfg->lua_state);
- if (! load_rspamd_config (tmp_cfg, FALSE)) {
- rspamd_set_logger (rspamd_main->cfg, g_quark_try_string ("main"), rspamd_main);
+ if (!load_rspamd_config (tmp_cfg, FALSE)) {
+ rspamd_set_logger (rspamd_main->cfg, g_quark_try_string (
+ "main"), rspamd_main);
msg_err ("cannot parse new config file, revert to old one");
rspamd_config_free (tmp_cfg);
}
}
/* Pre-init of cache */
rspamd->cfg->cache = g_new0 (struct symbols_cache, 1);
- rspamd->cfg->cache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ rspamd->cfg->cache->static_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
rspamd->cfg->cache->cfg = rspamd->cfg;
- rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (
+ rspamd_str_hash,
+ rspamd_str_equal);
/* Perform modules configuring */
l = g_list_first (rspamd->cfg->filters);
static void
set_worker_limits (struct rspamd_worker_conf *cf)
{
- struct rlimit rlmt;
+ struct rlimit rlmt;
if (cf->rlimit_nofile != 0) {
rlmt.rlim_cur = (rlim_t) cf->rlimit_nofile;
rlmt.rlim_max = (rlim_t) cf->rlimit_nofile;
- if (setrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
- msg_warn ("cannot set files rlimit: %d, %s", cf->rlimit_nofile, strerror (errno));
- }
+ if (setrlimit (RLIMIT_NOFILE, &rlmt) == -1) {
+ msg_warn ("cannot set files rlimit: %d, %s",
+ cf->rlimit_nofile,
+ strerror (errno));
+ }
}
if (cf->rlimit_maxcore != 0) {
rlmt.rlim_cur = (rlim_t) cf->rlimit_maxcore;
rlmt.rlim_max = (rlim_t) cf->rlimit_maxcore;
- if (setrlimit(RLIMIT_CORE, &rlmt) == -1) {
- msg_warn ("cannot set max core rlimit: %d, %s", cf->rlimit_maxcore, strerror (errno));
- }
+ if (setrlimit (RLIMIT_CORE, &rlmt) == -1) {
+ msg_warn ("cannot set max core rlimit: %d, %s",
+ cf->rlimit_maxcore,
+ strerror (errno));
+ }
}
}
-static struct rspamd_worker *
+static struct rspamd_worker *
fork_worker (struct rspamd_main *rspamd, struct rspamd_worker_conf *cf)
{
- struct rspamd_worker *cur;
+ struct rspamd_worker *cur;
/* Starting worker process */
cur = (struct rspamd_worker *)g_malloc (sizeof (struct rspamd_worker));
if (cur) {
break;
default:
/* Insert worker into worker's table, pid is index */
- g_hash_table_insert (rspamd->workers, GSIZE_TO_POINTER (cur->pid), cur);
+ g_hash_table_insert (rspamd->workers, GSIZE_TO_POINTER (
+ cur->pid), cur);
break;
}
}
set_alarm (guint seconds)
{
#ifdef HAVE_SETITIMER
- static struct itimerval itv;
+ static struct itimerval itv;
itv.it_interval.tv_sec = 0;
itv.it_interval.tv_usec = 0;
static GList *
create_listen_socket (const gchar *addr, gint port, gint listen_type)
{
- gint listen_sock = -1;
- GList *result, *cur;
+ gint listen_sock = -1;
+ GList *result, *cur;
/* Create listen sockets */
- result = make_universal_sockets_list (addr, port, listen_type, TRUE, TRUE, TRUE);
+ result = make_universal_sockets_list (addr,
+ port,
+ listen_type,
+ TRUE,
+ TRUE,
+ TRUE);
cur = result;
while (cur != NULL) {
static void
fork_delayed (struct rspamd_main *rspamd)
{
- GList *cur;
- struct rspamd_worker_conf *cf;
+ GList *cur;
+ struct rspamd_worker_conf *cf;
while (workers_pending != NULL) {
cur = workers_pending;
static inline uintptr_t
make_listen_key (gint ai, const gchar *addr, gint port)
{
- uintptr_t res = 0;
+ uintptr_t res = 0;
res = murmur32_hash (addr, strlen (addr));
res += murmur32_hash ((guchar *)&ai, sizeof (gint));
static void
spawn_workers (struct rspamd_main *rspamd)
{
- GList *cur, *ls;
- struct rspamd_worker_conf *cf;
- gint i, key;
- gpointer p;
+ GList *cur, *ls;
+ struct rspamd_worker_conf *cf;
+ gint i, key;
+ gpointer p;
struct rspamd_worker_bind_conf *bcf;
cur = rspamd->cfg->workers;
}
else {
if (cf->worker->has_socket) {
- LL_FOREACH (cf->bind_conf, bcf) {
- key = make_listen_key (bcf->ai, bcf->bind_host, bcf->bind_port);
- if ((p = g_hash_table_lookup (listen_sockets, GINT_TO_POINTER (key))) == NULL) {
+ LL_FOREACH (cf->bind_conf, bcf)
+ {
+ key = make_listen_key (bcf->ai,
+ bcf->bind_host,
+ bcf->bind_port);
+ if ((p =
+ g_hash_table_lookup (listen_sockets,
+ GINT_TO_POINTER (key))) == NULL) {
if (!bcf->is_systemd) {
/* Create listen socket */
- ls = create_listen_socket (bcf->bind_host, bcf->bind_port,
+ ls = create_listen_socket (bcf->bind_host,
+ bcf->bind_port,
cf->worker->listen_type);
}
else {
ls = systemd_get_socket (bcf->ai);
}
if (ls == NULL) {
- msg_err ("cannot listen on socket %s: %s", bcf->bind_host, strerror (errno));
+ msg_err ("cannot listen on socket %s: %s",
+ bcf->bind_host,
+ strerror (errno));
exit (-errno);
}
- g_hash_table_insert (listen_sockets, GINT_TO_POINTER (key), ls);
+ g_hash_table_insert (listen_sockets,
+ GINT_TO_POINTER (key), ls);
}
else {
/* We had socket for this type of worker */
if (cf->worker->unique) {
if (cf->count > 1) {
- msg_err ("cannot spawn more than 1 %s worker, so spawn one", cf->worker->name);
+ msg_err ("cannot spawn more than 1 %s worker, so spawn one",
+ cf->worker->name);
}
fork_worker (rspamd, cf);
}
static void
kill_old_workers (gpointer key, gpointer value, gpointer unused)
{
- struct rspamd_worker *w = value;
+ struct rspamd_worker *w = value;
kill (w->pid, SIGUSR2);
msg_info ("send signal to worker %P", w->pid);
static gboolean
wait_for_workers (gpointer key, gpointer value, gpointer unused)
{
- struct rspamd_worker *w = value;
- gint res = 0;
+ struct rspamd_worker *w = value;
+ gint res = 0;
if (got_alarm) {
got_alarm = 0;
}
}
- msg_info ("%s process %P terminated %s", g_quark_to_string (w->type), w->pid,
- got_alarm ? "hardly" : "softly");
+ msg_info ("%s process %P terminated %s", g_quark_to_string (
+ w->type), w->pid,
+ got_alarm ? "hardly" : "softly");
g_free (w->cf);
g_free (w);
static void
reopen_log_handler (gpointer key, gpointer value, gpointer unused)
{
- struct rspamd_worker *w = value;
+ struct rspamd_worker *w = value;
if (kill (w->pid, SIGUSR1) == -1) {
msg_err ("kill failed for pid %P: %s", w->pid, strerror (errno));
static void
preload_statfiles (struct rspamd_main *rspamd)
{
- struct rspamd_classifier_config *cf;
- struct rspamd_statfile_config *st;
- stat_file_t *stf;
- GList *cur_cl, *cur_st;
+ struct rspamd_classifier_config *cf;
+ struct rspamd_statfile_config *st;
+ stat_file_t *stf;
+ GList *cur_cl, *cur_st;
cur_cl = rspamd->cfg->classifiers;
while (cur_cl) {
cur_st = cf->statfiles;
while (cur_st) {
st = cur_st->data;
- stf = statfile_pool_open (rspamd->statfile_pool, st->path, st->size, FALSE);
+ stf = statfile_pool_open (rspamd->statfile_pool,
+ st->path,
+ st->size,
+ FALSE);
if (stf == NULL) {
msg_warn ("preload of %s from %s failed", st->symbol, st->path);
}
static gboolean
load_rspamd_config (struct rspamd_config *cfg, gboolean init_modules)
{
- GList *l;
- struct filter *filt;
- struct module_ctx *cur_module = NULL;
+ GList *l;
+ struct filter *filt;
+ struct module_ctx *cur_module = NULL;
- if (! rspamd_config_read (cfg, cfg->cfg_name, NULL,
- config_logger, rspamd_main)) {
+ if (!rspamd_config_read (cfg, cfg->cfg_name, NULL,
+ config_logger, rspamd_main)) {
return FALSE;
}
/* Strictly set temp dir */
if (!cfg->temp_dir) {
msg_warn ("tempdir is not set, trying to use $TMPDIR");
- cfg->temp_dir = rspamd_mempool_strdup (cfg->cfg_pool, getenv ("TMPDIR"));
+ cfg->temp_dir =
+ rspamd_mempool_strdup (cfg->cfg_pool, getenv ("TMPDIR"));
if (!cfg->temp_dir) {
msg_warn ("$TMPDIR is empty too, using /tmp as default");
/* Do post-load actions */
rspamd_config_post_load (cfg);
parse_filters_str (cfg, cfg->filters_str);
-
+
if (init_modules) {
/* Init C modules */
l = g_list_first (cfg->filters);
while (l) {
filt = l->data;
if (filt->module) {
- cur_module = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct module_ctx));
+ cur_module =
+ rspamd_mempool_alloc (cfg->cfg_pool,
+ sizeof (struct module_ctx));
if (filt->module->module_init_func (cfg, &cur_module) == 0) {
- g_hash_table_insert (cfg->c_modules, (gpointer) filt->module->name, cur_module);
+ g_hash_table_insert (cfg->c_modules,
+ (gpointer) filt->module->name,
+ cur_module);
}
}
l = g_list_next (l);
}
}
-
+
return TRUE;
}
static void
-init_cfg_cache (struct rspamd_config *cfg)
+init_cfg_cache (struct rspamd_config *cfg)
{
- if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg, cfg->cache_filename, FALSE)) {
+ if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg,
+ cfg->cache_filename, FALSE)) {
exit (EXIT_FAILURE);
}
}
static void
-print_symbols_cache (struct rspamd_config *cfg)
+print_symbols_cache (struct rspamd_config *cfg)
{
- GList *cur;
- struct cache_item *item;
- gint i;
+ GList *cur;
+ struct cache_item *item;
+ gint i;
- if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg, cfg->cache_filename, TRUE)) {
+ if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg,
+ cfg->cache_filename, TRUE)) {
exit (EXIT_FAILURE);
}
if (cfg->cache) {
printf ("Symbols cache\n");
- printf ("-----------------------------------------------------------------\n");
- printf ("| Pri | Symbol | Weight | Frequency | Avg. time |\n");
+ printf (
+ "-----------------------------------------------------------------\n");
+ printf (
+ "| Pri | Symbol | Weight | Frequency | Avg. time |\n");
i = 0;
cur = cfg->cache->negative_items;
while (cur) {
item = cur->data;
if (!item->is_callback) {
- printf ("-----------------------------------------------------------------\n");
- printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n", i, item->s->symbol, item->s->weight, item->s->frequency, item->s->avg_time);
+ printf (
+ "-----------------------------------------------------------------\n");
+ printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n",
+ i,
+ item->s->symbol,
+ item->s->weight,
+ item->s->frequency,
+ item->s->avg_time);
}
cur = g_list_next (cur);
- i ++;
+ i++;
}
cur = cfg->cache->static_items;
while (cur) {
item = cur->data;
if (!item->is_callback) {
- printf ("-----------------------------------------------------------------\n");
- printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n", i, item->s->symbol, item->s->weight, item->s->frequency, item->s->avg_time);
+ printf (
+ "-----------------------------------------------------------------\n");
+ printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n",
+ i,
+ item->s->symbol,
+ item->s->weight,
+ item->s->frequency,
+ item->s->avg_time);
}
cur = g_list_next (cur);
- i ++;
+ i++;
}
- printf ("-----------------------------------------------------------------\n");
+ printf (
+ "-----------------------------------------------------------------\n");
}
}
static gint
perform_lua_tests (struct rspamd_config *cfg)
{
- gint i, tests_num, res = EXIT_SUCCESS;
- gchar *cur_script;
- lua_State *L = cfg->lua_state;
+ gint i, tests_num, res = EXIT_SUCCESS;
+ gchar *cur_script;
+ lua_State *L = cfg->lua_state;
tests_num = g_strv_length (lua_tests);
- for (i = 0; i < tests_num; i ++) {
+ for (i = 0; i < tests_num; i++) {
if (luaL_loadfile (L, lua_tests[i]) != 0) {
- msg_err ("load of %s failed: %s", lua_tests[i], lua_tostring (L, -1));
+ msg_err ("load of %s failed: %s", lua_tests[i],
+ lua_tostring (L, -1));
res = EXIT_FAILURE;
continue;
}
/* do the call (0 arguments, N result) */
if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) {
- msg_info ("init of %s failed: %s", lua_tests[i], lua_tostring (L, -1));
+ msg_info ("init of %s failed: %s", lua_tests[i], lua_tostring (L,
+ -1));
res = EXIT_FAILURE;
continue;
}
if (lua_gettop (L) != 0) {
if (lua_tonumber (L, -1) == -1) {
- msg_info ("%s returned -1 that indicates configuration error", lua_tests[i]);
+ msg_info ("%s returned -1 that indicates configuration error",
+ lua_tests[i]);
res = EXIT_FAILURE;
continue;
}
msg_err ("must have openssl at least 1.0.0 to perform this action");
return EXIT_FAILURE;
# else
- gint i, tests_num, res = EXIT_SUCCESS, fd;
- guint diglen;
- gchar *cur_file, in_file[PATH_MAX],
- out_file[PATH_MAX], dig[EVP_MAX_MD_SIZE];
- gsize siglen;
- struct stat st;
- gpointer map, sig;
- EVP_PKEY *key = NULL;
- BIO *fbio;
- EVP_PKEY_CTX *key_ctx = NULL;
- EVP_MD_CTX *sign_ctx = NULL;
+ gint i, tests_num, res = EXIT_SUCCESS, fd;
+ guint diglen;
+ gchar *cur_file, in_file[PATH_MAX],
+ out_file[PATH_MAX], dig[EVP_MAX_MD_SIZE];
+ gsize siglen;
+ struct stat st;
+ gpointer map, sig;
+ EVP_PKEY *key = NULL;
+ BIO *fbio;
+ EVP_PKEY_CTX *key_ctx = NULL;
+ EVP_MD_CTX *sign_ctx = NULL;
/* Load private key */
fbio = BIO_new_file (privkey, "r");
if (fbio == NULL) {
msg_err ("cannot open private key %s, %s", privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
return ERR_get_error ();
}
if (!PEM_read_bio_PrivateKey (fbio, &key, rspamd_read_passphrase, NULL)) {
msg_err ("cannot read private key %s, %s", privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
return ERR_get_error ();
}
key_ctx = EVP_PKEY_CTX_new (key, NULL);
if (key_ctx == NULL) {
msg_err ("cannot parse private key %s, %s", privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
return ERR_get_error ();
}
if (EVP_PKEY_sign_init (key_ctx) <= 0) {
msg_err ("cannot parse private key %s, %s", privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
return ERR_get_error ();
}
if (EVP_PKEY_CTX_set_rsa_padding (key_ctx, RSA_PKCS1_PADDING) <= 0) {
msg_err ("cannot init private key %s, %s", privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
return ERR_get_error ();
}
if (EVP_PKEY_CTX_set_signature_md (key_ctx, EVP_sha256 ()) <= 0) {
msg_err ("cannot init signature private key %s, %s", privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ ERR_error_string (ERR_get_error (), NULL));
return ERR_get_error ();
}
tests_num = g_strv_length (sign_configs);
- for (i = 0; i < tests_num; i ++) {
+ for (i = 0; i < tests_num; i++) {
cur_file = sign_configs[i];
if (realpath (cur_file, in_file) == NULL) {
msg_err ("cannot resolve %s: %s", cur_file, strerror (errno));
continue;
}
- if ((map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+ if ((map =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
+ 0)) == MAP_FAILED) {
close (fd);
msg_err ("cannot mmap %s: %s", in_file, strerror (errno));
continue;
munmap (map, st.st_size);
if (EVP_PKEY_sign (key_ctx, NULL, &siglen, dig, diglen) <= 0) {
- msg_err ("cannot sign %s using private key %s, %s", in_file, privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ msg_err ("cannot sign %s using private key %s, %s",
+ in_file,
+ privkey,
+ ERR_error_string (ERR_get_error (), NULL));
continue;
}
sig = OPENSSL_malloc (siglen);
if (EVP_PKEY_sign (key_ctx, sig, &siglen, dig, diglen) <= 0) {
- msg_err ("cannot sign %s using private key %s, %s", in_file, privkey,
- ERR_error_string (ERR_get_error (), NULL));
+ msg_err ("cannot sign %s using private key %s, %s",
+ in_file,
+ privkey,
+ ERR_error_string (ERR_get_error (), NULL));
OPENSSL_free (sig);
continue;
}
rspamd_snprintf (out_file, sizeof (out_file), "%s.sig", in_file);
fd = open (out_file, O_WRONLY | O_CREAT | O_TRUNC, 00644);
if (fd == -1) {
- msg_err ("cannot open output file %s: %s", out_file, strerror (errno));
+ msg_err ("cannot open output file %s: %s", out_file, strerror (
+ errno));
OPENSSL_free (sig);
continue;
}
if (write (fd, sig, siglen) == -1) {
- msg_err ("cannot write to output file %s: %s", out_file, strerror (errno));
+ msg_err ("cannot write to output file %s: %s", out_file,
+ strerror (errno));
}
OPENSSL_free (sig);
close (fd);
gint
main (gint argc, gchar **argv, gchar **env)
{
- gint res = 0, i;
- struct sigaction signals;
- struct rspamd_worker *cur;
- struct rlimit rlim;
- struct filter *filt;
- pid_t wrk;
- GList *l;
- worker_t **pworker;
- GQuark type;
+ gint res = 0, i;
+ struct sigaction signals;
+ struct rspamd_worker *cur;
+ struct rlimit rlim;
+ struct filter *filt;
+ pid_t wrk;
+ GList *l;
+ worker_t **pworker;
+ GQuark type;
#ifdef HAVE_SA_SIGINFO
signals_info = g_queue_new ();
g_thread_init (NULL);
#endif
rspamd_main = (struct rspamd_main *)g_malloc0 (sizeof (struct rspamd_main));
- rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
- rspamd_main->cfg = (struct rspamd_config *)g_malloc0 (sizeof (struct rspamd_config));
+ rspamd_main->server_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
+ rspamd_main->cfg =
+ (struct rspamd_config *)g_malloc0 (sizeof (struct rspamd_config));
if (!rspamd_main || !rspamd_main->cfg) {
fprintf (stderr, "Cannot allocate memory\n");
init_title (argc, argv, env);
#endif
- rspamd_main->stat = rspamd_mempool_alloc_shared (rspamd_main->server_pool, sizeof (struct rspamd_stat));
+ rspamd_main->stat = rspamd_mempool_alloc_shared (rspamd_main->server_pool,
+ sizeof (struct rspamd_stat));
memset (rspamd_main->stat, 0, sizeof (struct rspamd_stat));
- rspamd_main->cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ rspamd_main->cfg->cfg_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
rspamd_config_defaults (rspamd_main->cfg);
memset (&signals, 0, sizeof (struct sigaction));
#ifdef HAVE_SETLOCALE
/* Set locale setting to C locale to avoid problems in future */
- setlocale (LC_ALL, "C");
- setlocale (LC_CTYPE, "C");
+ setlocale (LC_ALL, "C");
+ setlocale (LC_CTYPE, "C");
setlocale (LC_MESSAGES, "C");
- setlocale (LC_TIME, "C");
+ setlocale (LC_TIME, "C");
#endif
#ifdef HAVE_OPENSSL
detect_priv (rspamd_main);
rspamd_main->cfg->lua_state = init_lua (rspamd_main->cfg);
- rspamd_mempool_add_destructor (rspamd_main->cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_close, rspamd_main->cfg->lua_state);
+ rspamd_mempool_add_destructor (rspamd_main->cfg->cfg_pool,
+ (rspamd_mempool_destruct_t)lua_close, rspamd_main->cfg->lua_state);
pworker = &workers[0];
while (*pworker) {
/* Init string quarks */
(void)g_quark_from_static_string ((*pworker)->name);
- pworker ++;
+ pworker++;
}
/* Init counters */
- rspamd_main->counters = rspamd_hash_new_shared (rspamd_main->server_pool, rspamd_str_hash, rspamd_str_equal, 64);
+ rspamd_main->counters = rspamd_hash_new_shared (rspamd_main->server_pool,
+ rspamd_str_hash,
+ rspamd_str_equal,
+ 64);
/* Init listen sockets hash */
listen_sockets = g_hash_table_new (g_direct_hash, g_direct_equal);
/* Pre-init of cache */
rspamd_main->cfg->cache = g_new0 (struct symbols_cache, 1);
- rspamd_main->cfg->cache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ rspamd_main->cfg->cache->static_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
rspamd_main->cfg->cache->cfg = rspamd_main->cfg;
- rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (
+ rspamd_str_hash,
+ rspamd_str_equal);
/* If we want to test lua skip everything except it */
if (lua_tests != NULL && lua_tests[0] != NULL) {
}
/* Load config */
- if (! load_rspamd_config (rspamd_main->cfg, TRUE)) {
+ if (!load_rspamd_config (rspamd_main->cfg, TRUE)) {
exit (EXIT_FAILURE);
}
if (rspamd_pidfile != NULL) {
rspamd_main->cfg->pid_file = rspamd_pidfile;
}
-
+
/* Force debug log */
if (is_debug) {
rspamd_main->cfg->log_level = G_LOG_LEVEL_DEBUG;
/* Init events to test modules */
event_init ();
res = TRUE;
- if (! init_lua_filters (rspamd_main->cfg)) {
+ if (!init_lua_filters (rspamd_main->cfg)) {
res = FALSE;
}
/* Perform modules configuring */
/* Insert classifiers symbols */
(void)rspamd_config_insert_classify_symbols (rspamd_main->cfg);
- if (! validate_cache (rspamd_main->cfg->cache, rspamd_main->cfg, FALSE)) {
+ if (!validate_cache (rspamd_main->cfg->cache, rspamd_main->cfg,
+ FALSE)) {
res = FALSE;
}
if (dump_cache) {
rspamd_main->history = rspamd_roll_history_new (rspamd_main->server_pool);
msg_info ("rspamd " RVERSION " is starting, build id: " RID);
- rspamd_main->cfg->cfg_name = rspamd_mempool_strdup (rspamd_main->cfg->cfg_pool, rspamd_main->cfg->cfg_name);
+ rspamd_main->cfg->cfg_name = rspamd_mempool_strdup (
+ rspamd_main->cfg->cfg_pool,
+ rspamd_main->cfg->cfg_name);
/* Daemonize */
if (!rspamd_main->cfg->no_fork && daemon (0, 0) == -1) {
setproctitle ("main process");
/* Init statfile pool */
- rspamd_main->statfile_pool = statfile_pool_new (rspamd_main->server_pool, rspamd_main->cfg->mlock_statfile_pool);
+ rspamd_main->statfile_pool = statfile_pool_new (rspamd_main->server_pool,
+ rspamd_main->cfg->mlock_statfile_pool);
event_init ();
g_mime_init (0);
/* Init lua filters */
- if (! init_lua_filters (rspamd_main->cfg)) {
+ if (!init_lua_filters (rspamd_main->cfg)) {
msg_err ("error loading lua plugins");
exit (EXIT_FAILURE);
}
/* Maybe read roll history */
if (rspamd_main->cfg->history_file) {
- rspamd_roll_history_load (rspamd_main->history, rspamd_main->cfg->history_file);
+ rspamd_roll_history_load (rspamd_main->history,
+ rspamd_main->cfg->history_file);
}
/* Spawn workers */
spawn_workers (rspamd_main);
/* Signal processing cycle */
- for (;;) {
+ for (;; ) {
msg_debug ("calling sigsuspend");
sigemptyset (&signals.sa_mask);
sigsuspend (&signals.sa_mask);
msg_debug ("catch SIGCHLD signal, finding terminated worker");
/* Remove dead child form children list */
wrk = waitpid (0, &res, 0);
- if ((cur = g_hash_table_lookup (rspamd_main->workers, GSIZE_TO_POINTER (wrk))) != NULL) {
+ if ((cur =
+ g_hash_table_lookup (rspamd_main->workers,
+ GSIZE_TO_POINTER (wrk))) != NULL) {
/* Unlink dead process from queue and hash table */
- g_hash_table_remove (rspamd_main->workers, GSIZE_TO_POINTER (wrk));
+ g_hash_table_remove (rspamd_main->workers, GSIZE_TO_POINTER (
+ wrk));
if (WIFEXITED (res) && WEXITSTATUS (res) == 0) {
/* Normal worker termination, do not fork one more */
- msg_info ("%s process %P terminated normally", g_quark_to_string (cur->type), cur->pid);
+ msg_info ("%s process %P terminated normally",
+ g_quark_to_string (cur->type),
+ cur->pid);
}
else {
if (WIFSIGNALED (res)) {
- msg_warn ("%s process %P terminated abnormally by signal: %d", g_quark_to_string (cur->type), cur->pid, WTERMSIG (res));
+ msg_warn (
+ "%s process %P terminated abnormally by signal: %d",
+ g_quark_to_string (cur->type),
+ cur->pid,
+ WTERMSIG (res));
}
else {
- msg_warn ("%s process %P terminated abnormally", g_quark_to_string (cur->type), cur->pid);
+ msg_warn ("%s process %P terminated abnormally",
+ g_quark_to_string (cur->type),
+ cur->pid);
}
/* Fork another worker in replace of dead one */
delay_fork (cur->cf);
g_free (cur);
}
else {
- for (i = 0; i < (gint)other_workers->len; i ++) {
+ for (i = 0; i < (gint)other_workers->len; i++) {
if (g_array_index (other_workers, pid_t, i) == wrk) {
g_array_remove_index_fast (other_workers, i);
msg_info ("related process %P terminated", wrk);
}
if (do_restart) {
do_restart = 0;
- reopen_log_priv (rspamd_main->logger, rspamd_main->workers_uid, rspamd_main->workers_gid);
+ reopen_log_priv (rspamd_main->logger,
+ rspamd_main->workers_uid,
+ rspamd_main->workers_gid);
msg_info ("rspamd " RVERSION " is restarting");
g_hash_table_foreach (rspamd_main->workers, kill_old_workers, NULL);
remove_all_maps (rspamd_main->cfg);
}
if (do_reopen_log) {
do_reopen_log = 0;
- reopen_log_priv (rspamd_main->logger, rspamd_main->workers_uid, rspamd_main->workers_gid);
- g_hash_table_foreach (rspamd_main->workers, reopen_log_handler, NULL);
+ reopen_log_priv (rspamd_main->logger,
+ rspamd_main->workers_uid,
+ rspamd_main->workers_gid);
+ g_hash_table_foreach (rspamd_main->workers, reopen_log_handler,
+ NULL);
}
if (got_alarm) {
got_alarm = 0;
sigaddset (&signals.sa_mask, SIGTERM);
sigaction (SIGALRM, &signals, NULL);
sigaction (SIGTERM, &signals, NULL);
- sigaction (SIGINT, &signals, NULL);
+ sigaction (SIGINT, &signals, NULL);
sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
/* Set alarm for hard termination */
set_alarm (HARD_TERMINATION_TIME);
/* Maybe save roll history */
if (rspamd_main->cfg->history_file) {
- rspamd_roll_history_save (rspamd_main->history, rspamd_main->cfg->history_file);
+ rspamd_roll_history_save (rspamd_main->history,
+ rspamd_main->cfg->history_file);
}
msg_info ("terminating...");
return (res);
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
#ifndef RSPAMD_MAIN_H
#define RSPAMD_MAIN_H
+#include "buffer.h"
#include "config.h"
-#include "fstring.h"
-#include "mem_pool.h"
-#include "statfile.h"
-#include "url.h"
-#include "protocol.h"
+#include "events.h"
#include "filter.h"
-#include "buffer.h"
+#include "fstring.h"
#include "hash.h"
-#include "events.h"
-#include "util.h"
+#include "http.h"
#include "logger.h"
+#include "mem_pool.h"
+#include "protocol.h"
#include "roll_history.h"
-#include "http.h"
+#include "statfile.h"
#include "task.h"
+#include "url.h"
+#include "util.h"
#include "worker_util.h"
/* Default values */
#define CR '\r'
#define LF '\n'
-/**
- * Worker process structure
+/**
+ * Worker process structure
*/
struct rspamd_worker {
- pid_t pid; /**< pid of worker */
- gboolean is_initialized; /**< is initialized */
- gboolean is_dying; /**< if worker is going to shutdown */
- gboolean pending; /**< if worker is pending to run */
- struct rspamd_main *srv; /**< pointer to server structure */
- GQuark type; /**< process type */
- struct event sig_ev_usr1; /**< signals event */
- struct event sig_ev_usr2; /**< signals event */
- GList *accept_events; /**< socket events */
- struct rspamd_worker_conf *cf; /**< worker config data */
- gpointer ctx; /**< worker's specific data */
+ pid_t pid; /**< pid of worker */
+ gboolean is_initialized; /**< is initialized */
+ gboolean is_dying; /**< if worker is going to shutdown */
+ gboolean pending; /**< if worker is pending to run */
+ struct rspamd_main *srv; /**< pointer to server structure */
+ GQuark type; /**< process type */
+ struct event sig_ev_usr1; /**< signals event */
+ struct event sig_ev_usr2; /**< signals event */
+ GList *accept_events; /**< socket events */
+ struct rspamd_worker_conf *cf; /**< worker config data */
+ gpointer ctx; /**< worker's specific data */
};
/**
struct rspamd_dns_resolver;
struct rspamd_task;
-/**
+/**
* Server statistics
*/
struct rspamd_stat {
- guint messages_scanned; /**< total number of messages scanned */
- guint actions_stat[METRIC_ACTION_NOACTION + 1]; /**< statistic for each action */
- guint connections_count; /**< total connections count */
- guint control_connections_count; /**< connections count to control interface */
- guint messages_learned; /**< messages learned */
- guint fuzzy_hashes; /**< number of fuzzy hashes stored */
- guint fuzzy_hashes_expired; /**< number of fuzzy hashes expired */
+ guint messages_scanned; /**< total number of messages scanned */
+ guint actions_stat[METRIC_ACTION_NOACTION + 1]; /**< statistic for each action */
+ guint connections_count; /**< total connections count */
+ guint control_connections_count; /**< connections count to control interface */
+ guint messages_learned; /**< messages learned */
+ guint fuzzy_hashes; /**< number of fuzzy hashes stored */
+ guint fuzzy_hashes_expired; /**< number of fuzzy hashes expired */
};
/**
* Struct that determine main server object (for logging purposes)
*/
struct rspamd_main {
- struct rspamd_config *cfg; /**< pointer to config structure */
- pid_t pid; /**< main pid */
+ struct rspamd_config *cfg; /**< pointer to config structure */
+ pid_t pid; /**< main pid */
/* Pid file structure */
- rspamd_pidfh_t *pfh; /**< struct pidfh for pidfile */
- GQuark type; /**< process type */
- guint ev_initialized; /**< is event system is initialized */
- struct rspamd_stat *stat; /**< pointer to statistics */
+ rspamd_pidfh_t *pfh; /**< struct pidfh for pidfile */
+ GQuark type; /**< process type */
+ guint ev_initialized; /**< is event system is initialized */
+ struct rspamd_stat *stat; /**< pointer to statistics */
- rspamd_mempool_t *server_pool; /**< server's memory pool */
- statfile_pool_t *statfile_pool; /**< shared statfiles pool */
+ rspamd_mempool_t *server_pool; /**< server's memory pool */
+ statfile_pool_t *statfile_pool; /**< shared statfiles pool */
GHashTable *workers; /**< workers pool indexed by pid */
- rspamd_hash_t *counters; /**< symbol cache counters */
+ rspamd_hash_t *counters; /**< symbol cache counters */
rspamd_logger_t *logger;
- uid_t workers_uid; /**< worker's uid running to */
- gid_t workers_gid; /**< worker's gid running to */
- gboolean is_privilleged; /**< true if run in privilleged mode */
- struct roll_history *history; /**< rolling history */
+ uid_t workers_uid; /**< worker's uid running to */
+ gid_t workers_gid; /**< worker's gid running to */
+ gboolean is_privilleged; /**< true if run in privilleged mode */
+ struct roll_history *history; /**< rolling history */
};
struct counter_data {
*/
struct controller_command;
struct controller_session;
-typedef gboolean (*controller_func_t)(gchar **args, struct controller_session *session);
+typedef gboolean (*controller_func_t)(gchar **args,
+ struct controller_session *session);
struct controller_session {
- struct rspamd_worker *worker; /**< pointer to worker structure (controller in fact) */
+ struct rspamd_worker *worker; /**< pointer to worker structure (controller in fact) */
enum {
STATE_COMMAND,
STATE_HEADER,
STATE_OTHER,
STATE_WAIT,
STATE_WEIGHTS
- } state; /**< current session state */
- gint sock; /**< socket descriptor */
+ } state; /**< current session state */
+ gint sock; /**< socket descriptor */
/* Access to authorized commands */
- gboolean authorized; /**< whether this session is authorized */
- gboolean restful; /**< whether this session is a restful session */
- GHashTable *kwargs; /**< keyword arguments for restful command */
- struct controller_command *cmd; /**< real command */
- rspamd_mempool_t *session_pool; /**< memory pool for session */
- struct rspamd_config *cfg; /**< pointer to config file */
- gchar *learn_rcpt; /**< recipient for learning */
- gchar *learn_from; /**< from address for learning */
+ gboolean authorized; /**< whether this session is authorized */
+ gboolean restful; /**< whether this session is a restful session */
+ GHashTable *kwargs; /**< keyword arguments for restful command */
+ struct controller_command *cmd; /**< real command */
+ rspamd_mempool_t *session_pool; /**< memory pool for session */
+ struct rspamd_config *cfg; /**< pointer to config file */
+ gchar *learn_rcpt; /**< recipient for learning */
+ gchar *learn_from; /**< from address for learning */
struct rspamd_classifier_config *learn_classifier;
- gchar *learn_symbol; /**< symbol to train */
- double learn_multiplier; /**< multiplier for learning */
- rspamd_io_dispatcher_t *dispatcher; /**< IO dispatcher object */
- f_str_t *learn_buf; /**< learn input */
- GList *parts; /**< extracted mime parts */
- gint in_class; /**< positive or negative learn */
+ gchar *learn_symbol; /**< symbol to train */
+ double learn_multiplier; /**< multiplier for learning */
+ rspamd_io_dispatcher_t *dispatcher; /**< IO dispatcher object */
+ f_str_t *learn_buf; /**< learn input */
+ GList *parts; /**< extracted mime parts */
+ gint in_class; /**< positive or negative learn */
gboolean (*other_handler)(struct controller_session *session,
- f_str_t *in); /**< other command handler to execute at the end of processing */
- void *other_data; /**< and its data */
- controller_func_t custom_handler; /**< custom command handler */
- struct rspamd_async_session* s; /**< async session object */
+ f_str_t *in); /**< other command handler to execute at the end of processing */
+ void *other_data; /**< and its data */
+ controller_func_t custom_handler; /**< custom command handler */
+ struct rspamd_async_session * s; /**< async session object */
struct rspamd_task *learn_task;
- struct rspamd_dns_resolver *resolver; /**< DNS resolver */
- struct event_base *ev_base; /**< Event base */
+ struct rspamd_dns_resolver *resolver; /**< DNS resolver */
+ struct event_base *ev_base; /**< Event base */
};
/**
* Common structure representing C module context
*/
struct module_ctx {
- gint (*filter)(struct rspamd_task *task); /**< pointer to headers process function */
+ gint (*filter)(struct rspamd_task *task); /**< pointer to headers process function */
};
/**
* Register custom controller function
*/
-void register_custom_controller_command (const gchar *name, controller_func_t handler, gboolean privilleged, gboolean require_message);
+void register_custom_controller_command (const gchar *name,
+ controller_func_t handler,
+ gboolean privilleged,
+ gboolean require_message);
/**
* If set, reopen log file on next write
#endif
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
* (e.g. if threshold is 0.1 than charset change should occure more often than in 10 symbols), default: 0.1
*/
+#include "cfg_file.h"
#include "config.h"
+#include "expressions.h"
#include "main.h"
#include "message.h"
-#include "cfg_file.h"
-#include "expressions.h"
#define DEFAULT_SYMBOL "R_CHARSET_MIXED"
#define DEFAULT_THRESHOLD 0.1
};
struct chartable_ctx {
- gint (*filter) (struct rspamd_task * task);
- const gchar *symbol;
- double threshold;
+ gint (*filter) (struct rspamd_task * task);
+ const gchar *symbol;
+ double threshold;
- rspamd_mempool_t *chartable_pool;
+ rspamd_mempool_t *chartable_pool;
};
-static struct chartable_ctx *chartable_module_ctx = NULL;
+static struct chartable_ctx *chartable_module_ctx = NULL;
-static gint chartable_mime_filter (struct rspamd_task *task);
-static void chartable_symbol_callback (struct rspamd_task *task, void *unused);
+static gint chartable_mime_filter (struct rspamd_task *task);
+static void chartable_symbol_callback (struct rspamd_task *task, void *unused);
gint
chartable_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
chartable_module_ctx = g_malloc (sizeof (struct chartable_ctx));
chartable_module_ctx->filter = chartable_mime_filter;
- chartable_module_ctx->chartable_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ chartable_module_ctx->chartable_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
*ctx = (struct module_ctx *)chartable_module_ctx;
gint
chartable_module_config (struct rspamd_config *cfg)
{
- const ucl_object_t *value;
- gint res = TRUE;
+ const ucl_object_t *value;
+ gint res = TRUE;
- if ((value = rspamd_config_get_module_opt (cfg, "chartable", "symbol")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "chartable", "symbol")) != NULL) {
chartable_module_ctx->symbol = ucl_obj_tostring (value);
}
else {
chartable_module_ctx->symbol = DEFAULT_SYMBOL;
- }
- if ((value = rspamd_config_get_module_opt (cfg, "chartable", "threshold")) != NULL) {
+ }
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "chartable", "threshold")) != NULL) {
if (!ucl_obj_todouble_safe (value, &chartable_module_ctx->threshold)) {
msg_warn ("invalid numeric value");
chartable_module_ctx->threshold = DEFAULT_THRESHOLD;
chartable_module_ctx->threshold = DEFAULT_THRESHOLD;
}
- register_symbol (&cfg->cache, chartable_module_ctx->symbol, 1, chartable_symbol_callback, NULL);
+ register_symbol (&cfg->cache,
+ chartable_module_ctx->symbol,
+ 1,
+ chartable_symbol_callback,
+ NULL);
return res;
}
return chartable_module_config (cfg);
}
-static gboolean
+static gboolean
check_part (struct mime_text_part *part, gboolean raw_mode)
{
- guchar *p, *p1;
- gunichar c, t;
- GUnicodeScript scc, sct;
- guint32 mark = 0, total = 0, max = 0, i;
- guint32 remain = part->content->len;
- guint32 scripts[G_UNICODE_SCRIPT_NKO];
- GUnicodeScript sel = 0;
+ guchar *p, *p1;
+ gunichar c, t;
+ GUnicodeScript scc, sct;
+ guint32 mark = 0, total = 0, max = 0, i;
+ guint32 remain = part->content->len;
+ guint32 scripts[G_UNICODE_SCRIPT_NKO];
+ GUnicodeScript sel = 0;
p = part->content->data;
if (part->is_raw || raw_mode) {
while (remain > 1) {
- if ((g_ascii_isalpha (*p) && (*(p + 1) & 0x80)) || ((*p & 0x80) && g_ascii_isalpha (*(p + 1)))) {
+ if ((g_ascii_isalpha (*p) &&
+ (*(p + 1) & 0x80)) ||
+ ((*p & 0x80) && g_ascii_isalpha (*(p + 1)))) {
mark++;
total++;
}
/* Current and next symbols are of one class */
- else if (((*p & 0x80) && (*(p + 1) & 0x80)) || (g_ascii_isalpha (*p) && g_ascii_isalpha (*(p + 1)))) {
+ else if (((*p & 0x80) &&
+ (*(p + 1) & 0x80)) ||
+ (g_ascii_isalpha (*p) && g_ascii_isalpha (*(p + 1)))) {
total++;
}
p++;
memset (&scripts, 0, sizeof (scripts));
while (remain > 0) {
c = g_utf8_get_char_validated (p, remain);
- if (c == (gunichar) -2 || c == (gunichar) -1) {
+ if (c == (gunichar) - 2 || c == (gunichar) - 1) {
/* Invalid characters detected, stop processing */
return FALSE;
}
scc = g_unichar_get_script (c);
if (scc < (gint)G_N_ELEMENTS (scripts)) {
- scripts[scc] ++;
+ scripts[scc]++;
}
p1 = g_utf8_next_char (p);
remain -= p1 - p;
if (remain > 0) {
t = g_utf8_get_char_validated (p, remain);
- if (t == (gunichar) -2 || t == (gunichar) -1) {
+ if (t == (gunichar) - 2 || t == (gunichar) - 1) {
/* Invalid characters detected, stop processing */
return FALSE;
}
}
}
/* Detect the mostly charset of this part */
- for (i = 0; i < G_N_ELEMENTS (scripts); i ++) {
+ for (i = 0; i < G_N_ELEMENTS (scripts); i++) {
if (scripts[i] > max) {
max = scripts[i];
sel = i;
static void
chartable_symbol_callback (struct rspamd_task *task, void *unused)
{
- GList *cur;
- struct mime_text_part *part;
+ GList *cur;
+ struct mime_text_part *part;
cur = g_list_first (task->text_parts);
while (cur) {
* - skip_mutli (flag): skip messages with multiply dkim signatures
*/
+#include "cfg_file.h"
#include "config.h"
+#include "dkim.h"
+#include "expressions.h"
+#include "hash.h"
#include "main.h"
+#include "map.h"
#include "message.h"
-#include "cfg_file.h"
-#include "expressions.h"
#include "util.h"
-#include "map.h"
-#include "dkim.h"
-#include "hash.h"
#define DEFAULT_SYMBOL_REJECT "R_DKIM_REJECT"
#define DEFAULT_SYMBOL_TEMPFAIL "R_DKIM_TEMPFAIL"
#define DEFAULT_TIME_JITTER 60
struct dkim_ctx {
- gint (*filter) (struct rspamd_task * task);
- const gchar *symbol_reject;
- const gchar *symbol_tempfail;
- const gchar *symbol_allow;
-
- rspamd_mempool_t *dkim_pool;
- radix_tree_t *whitelist_ip;
- GHashTable *dkim_domains;
- guint strict_multiplier;
- guint time_jitter;
- rspamd_lru_hash_t *dkim_hash;
- gboolean trusted_only;
- gboolean skip_multi;
+ gint (*filter) (struct rspamd_task * task);
+ const gchar *symbol_reject;
+ const gchar *symbol_tempfail;
+ const gchar *symbol_allow;
+
+ rspamd_mempool_t *dkim_pool;
+ radix_tree_t *whitelist_ip;
+ GHashTable *dkim_domains;
+ guint strict_multiplier;
+ guint time_jitter;
+ rspamd_lru_hash_t *dkim_hash;
+ gboolean trusted_only;
+ gboolean skip_multi;
};
-static struct dkim_ctx *dkim_module_ctx = NULL;
+static struct dkim_ctx *dkim_module_ctx = NULL;
-static void dkim_symbol_callback (struct rspamd_task *task, void *unused);
+static void dkim_symbol_callback (struct rspamd_task *task, void *unused);
/* Initialization */
gint dkim_module_init (struct rspamd_config *cfg, struct module_ctx **ctx);
{
dkim_module_ctx = g_malloc0 (sizeof (struct dkim_ctx));
- dkim_module_ctx->dkim_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ dkim_module_ctx->dkim_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
*ctx = (struct module_ctx *)dkim_module_ctx;
gint
dkim_module_config (struct rspamd_config *cfg)
{
- const ucl_object_t *value;
- gint res = TRUE;
- guint cache_size, cache_expire;
- gboolean got_trusted = FALSE;
+ const ucl_object_t *value;
+ gint res = TRUE;
+ guint cache_size, cache_expire;
+ gboolean got_trusted = FALSE;
dkim_module_ctx->whitelist_ip = radix_tree_create ();
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "symbol_reject")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "symbol_reject")) != NULL) {
dkim_module_ctx->symbol_reject = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_reject = DEFAULT_SYMBOL_REJECT;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "symbol_tempfail")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim",
+ "symbol_tempfail")) != NULL) {
dkim_module_ctx->symbol_tempfail = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_tempfail = DEFAULT_SYMBOL_TEMPFAIL;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "symbol_allow")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "symbol_allow")) != NULL) {
dkim_module_ctx->symbol_allow = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_allow = DEFAULT_SYMBOL_ALLOW;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "dkim_cache_size")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim",
+ "dkim_cache_size")) != NULL) {
cache_size = ucl_obj_toint (value);
}
else {
cache_size = DEFAULT_CACHE_SIZE;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "dkim_cache_expire")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim",
+ "dkim_cache_expire")) != NULL) {
cache_expire = ucl_obj_todouble (value);
}
else {
cache_expire = DEFAULT_CACHE_MAXAGE;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "time_jitter")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "time_jitter")) != NULL) {
dkim_module_ctx->time_jitter = ucl_obj_todouble (value);
}
else {
dkim_module_ctx->time_jitter = DEFAULT_TIME_JITTER;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "whitelist")) != NULL) {
- if (! add_map (cfg, ucl_obj_tostring (value),
- "DKIM whitelist", read_radix_list, fin_radix_list,
- (void **)&dkim_module_ctx->whitelist_ip)) {
- msg_warn ("cannot load whitelist from %s", ucl_obj_tostring (value));
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "whitelist")) != NULL) {
+ if (!add_map (cfg, ucl_obj_tostring (value),
+ "DKIM whitelist", read_radix_list, fin_radix_list,
+ (void **)&dkim_module_ctx->whitelist_ip)) {
+ msg_warn ("cannot load whitelist from %s",
+ ucl_obj_tostring (value));
}
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "domains")) != NULL) {
- if (! add_map (cfg, ucl_obj_tostring (value),
- "DKIM domains", read_kv_list, fin_kv_list,
- (void **)&dkim_module_ctx->dkim_domains)) {
- msg_warn ("cannot load dkim domains list from %s", ucl_obj_tostring (value));
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "domains")) != NULL) {
+ if (!add_map (cfg, ucl_obj_tostring (value),
+ "DKIM domains", read_kv_list, fin_kv_list,
+ (void **)&dkim_module_ctx->dkim_domains)) {
+ msg_warn ("cannot load dkim domains list from %s",
+ ucl_obj_tostring (value));
}
else {
got_trusted = TRUE;
}
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "strict_multiplier")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim",
+ "strict_multiplier")) != NULL) {
dkim_module_ctx->strict_multiplier = ucl_obj_toint (value);
}
else {
dkim_module_ctx->strict_multiplier = 1;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "trusted_only")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "trusted_only")) != NULL) {
dkim_module_ctx->trusted_only = ucl_obj_toboolean (value);
}
else {
dkim_module_ctx->trusted_only = FALSE;
}
- if ((value = rspamd_config_get_module_opt (cfg, "dkim", "skip_multi")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "dkim", "skip_multi")) != NULL) {
dkim_module_ctx->skip_multi = ucl_obj_toboolean (value);
}
else {
}
if (dkim_module_ctx->trusted_only && !got_trusted) {
- msg_err ("trusted_only option is set and no trusted domains are defined; disabling dkim module completely as it is useless in this case");
+ msg_err (
+ "trusted_only option is set and no trusted domains are defined; disabling dkim module completely as it is useless in this case");
}
else {
- register_symbol (&cfg->cache, dkim_module_ctx->symbol_reject, 1, dkim_symbol_callback, NULL);
- register_virtual_symbol (&cfg->cache, dkim_module_ctx->symbol_tempfail, 1);
- register_virtual_symbol (&cfg->cache, dkim_module_ctx->symbol_allow, 1);
-
- dkim_module_ctx->dkim_hash = rspamd_lru_hash_new (rspamd_strcase_hash, rspamd_strcase_equal,
- cache_size, cache_expire, g_free, (GDestroyNotify)rspamd_dkim_key_free);
+ register_symbol (&cfg->cache,
+ dkim_module_ctx->symbol_reject,
+ 1,
+ dkim_symbol_callback,
+ NULL);
+ register_virtual_symbol (&cfg->cache,
+ dkim_module_ctx->symbol_tempfail,
+ 1);
+ register_virtual_symbol (&cfg->cache,
+ dkim_module_ctx->symbol_allow,
+ 1);
+
+ dkim_module_ctx->dkim_hash = rspamd_lru_hash_new (rspamd_strcase_hash,
+ rspamd_strcase_equal,
+ cache_size,
+ cache_expire,
+ g_free,
+ (GDestroyNotify)rspamd_dkim_key_free);
#ifndef HAVE_OPENSSL
- msg_warn ("openssl is not found so dkim rsa check is disabled, only check body hash, it is NOT safe to trust these results");
+ msg_warn (
+ "openssl is not found so dkim rsa check is disabled, only check body hash, it is NOT safe to trust these results");
#endif
}
if (dkim_module_ctx->dkim_domains) {
g_hash_table_destroy (dkim_module_ctx->dkim_domains);
}
- dkim_module_ctx->dkim_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ dkim_module_ctx->dkim_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
return dkim_module_config (cfg);
}
static gboolean
dkim_module_parse_strict (const gchar *value, gint *allow, gint *deny)
{
- const gchar *colon;
- gulong val;
+ const gchar *colon;
+ gulong val;
colon = strchr (value, ':');
if (colon) {
if (rspamd_strtoul (value, colon - value, &val)) {
*deny = val;
- colon ++;
+ colon++;
if (rspamd_strtoul (colon, strlen (colon), &val)) {
*allow = val;
return TRUE;
}
static void
-dkim_module_check (struct rspamd_task *task, rspamd_dkim_context_t *ctx, rspamd_dkim_key_t *key)
+dkim_module_check (struct rspamd_task *task,
+ rspamd_dkim_context_t *ctx,
+ rspamd_dkim_key_t *key)
{
- gint res, score_allow = 1, score_deny = 1;
- const gchar *strict_value;
+ gint res, score_allow = 1, score_deny = 1;
+ const gchar *strict_value;
- msg_debug ("check dkim signature for %s domain from %s", ctx->domain, ctx->dns_key);
+ msg_debug ("check dkim signature for %s domain from %s",
+ ctx->domain,
+ ctx->dns_key);
res = rspamd_dkim_check (ctx, key, task);
if (dkim_module_ctx->dkim_domains != NULL) {
/* Perform strict check */
- if ((strict_value = g_hash_table_lookup (dkim_module_ctx->dkim_domains, ctx->domain)) != NULL) {
- if (!dkim_module_parse_strict (strict_value, &score_allow, &score_deny)) {
+ if ((strict_value =
+ g_hash_table_lookup (dkim_module_ctx->dkim_domains,
+ ctx->domain)) != NULL) {
+ if (!dkim_module_parse_strict (strict_value, &score_allow,
+ &score_deny)) {
score_allow = dkim_module_ctx->strict_multiplier;
score_deny = dkim_module_ctx->strict_multiplier;
- msg_debug ("no specific score found for %s domain, using %d for it", ctx->domain, score_deny);
+ msg_debug (
+ "no specific score found for %s domain, using %d for it",
+ ctx->domain,
+ score_deny);
}
else {
- msg_debug ("specific score found for %s domain: using %d for deny and %d for allow",
- ctx->dns_key, score_deny, score_allow);
+ msg_debug (
+ "specific score found for %s domain: using %d for deny and %d for allow",
+ ctx->dns_key,
+ score_deny,
+ score_allow);
}
}
}
}
static void
-dkim_module_key_handler (rspamd_dkim_key_t *key, gsize keylen, rspamd_dkim_context_t *ctx, gpointer ud, GError *err)
+dkim_module_key_handler (rspamd_dkim_key_t *key,
+ gsize keylen,
+ rspamd_dkim_context_t *ctx,
+ gpointer ud,
+ GError *err)
{
- struct rspamd_task *task = ud;
+ struct rspamd_task *task = ud;
if (key != NULL) {
/* Add new key to the lru cache */
- rspamd_lru_hash_insert (dkim_module_ctx->dkim_hash, g_strdup (ctx->dns_key),
- key, task->tv.tv_sec, key->ttl);
+ rspamd_lru_hash_insert (dkim_module_ctx->dkim_hash,
+ g_strdup (ctx->dns_key),
+ key, task->tv.tv_sec, key->ttl);
dkim_module_check (task, ctx, key);
}
else {
msg_info ("cannot get key for domain %s", ctx->dns_key);
if (err != NULL) {
insert_result (task, dkim_module_ctx->symbol_tempfail, 1,
- g_list_prepend (NULL, rspamd_mempool_strdup (task->task_pool, err->message)));
+ g_list_prepend (NULL,
+ rspamd_mempool_strdup (task->task_pool, err->message)));
}
else {
static void
dkim_symbol_callback (struct rspamd_task *task, void *unused)
{
- GList *hlist;
- rspamd_dkim_context_t *ctx;
- rspamd_dkim_key_t *key;
- GError *err = NULL;
+ GList *hlist;
+ rspamd_dkim_context_t *ctx;
+ rspamd_dkim_key_t *key;
+ GError *err = NULL;
/* First check if a message has its signature */
- hlist = message_get_header (task->task_pool, task->message, DKIM_SIGNHEADER, FALSE);
+ hlist = message_get_header (task->task_pool,
+ task->message,
+ DKIM_SIGNHEADER,
+ FALSE);
if (hlist != NULL) {
/* Check whitelist */
msg_debug ("dkim signature found");
if (task->from_addr.af == AF_INET ||
- radix32tree_find (dkim_module_ctx->whitelist_ip,
- ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
+ radix32tree_find (dkim_module_ctx->whitelist_ip,
+ ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) ==
+ RADIX_NO_VALUE) {
/* Parse signature */
msg_debug ("create dkim signature");
/*
*/
if (dkim_module_ctx->skip_multi) {
if (hlist->next != NULL) {
- msg_info ("<%s> skip dkim check as it has several dkim signatures", task->message_id);
+ msg_info (
+ "<%s> skip dkim check as it has several dkim signatures",
+ task->message_id);
return;
}
}
hlist = g_list_last (hlist);
- ctx = rspamd_create_dkim_context (hlist->data, task->task_pool, dkim_module_ctx->time_jitter, &err);
+ ctx = rspamd_create_dkim_context (hlist->data,
+ task->task_pool,
+ dkim_module_ctx->time_jitter,
+ &err);
if (ctx == NULL) {
msg_info ("cannot parse DKIM context: %s", err->message);
g_error_free (err);
}
else {
/* Get key */
- if (dkim_module_ctx->trusted_only && (dkim_module_ctx->dkim_domains == NULL ||
- g_hash_table_lookup (dkim_module_ctx->dkim_domains, ctx->domain) == NULL)) {
+ if (dkim_module_ctx->trusted_only &&
+ (dkim_module_ctx->dkim_domains == NULL ||
+ g_hash_table_lookup (dkim_module_ctx->dkim_domains,
+ ctx->domain) == NULL)) {
msg_debug ("skip dkim check for %s domain", ctx->domain);
return;
}
- key = rspamd_lru_hash_lookup (dkim_module_ctx->dkim_hash, ctx->dns_key, task->tv.tv_sec);
+ key = rspamd_lru_hash_lookup (dkim_module_ctx->dkim_hash,
+ ctx->dns_key,
+ task->tv.tv_sec);
if (key != NULL) {
debug_task ("found key for %s in cache", ctx->dns_key);
dkim_module_check (task, ctx, key);
}
else {
debug_task ("request key for %s from DNS", ctx->dns_key);
- task->dns_requests ++;
- rspamd_get_dkim_key (ctx, task->resolver, task->s, dkim_module_key_handler, task);
+ task->dns_requests++;
+ rspamd_get_dkim_key (ctx,
+ task->resolver,
+ task->s,
+ dkim_module_key_handler,
+ task);
}
}
}
* - symbol (string): symbol to insert (default: 'R_FUZZY')
* - max_score (double): maximum score to that weights of hashes would be normalized (default: 0 - no normalization)
*
- * - fuzzy_map (string): a string that contains map in format { fuzzy_key => [ symbol, weight ] } where fuzzy_key is number of
+ * - fuzzy_map (string): a string that contains map in format { fuzzy_key => [ symbol, weight ] } where fuzzy_key is number of
* fuzzy list. This string itself should be in format 1:R_FUZZY_SAMPLE1:10,2:R_FUZZY_SAMPLE2:1 etc, where first number is fuzzy
* key, second is symbol to insert and third - weight for normalization
*
* fuzzy hashes
*/
+#include "cfg_file.h"
#include "config.h"
+#include "expressions.h"
+#include "fuzzy_storage.h"
+#include "images.h"
#include "main.h"
+#include "map.h"
#include "message.h"
-#include "cfg_file.h"
-#include "expressions.h"
#include "util.h"
-#include "map.h"
-#include "images.h"
-#include "fuzzy_storage.h"
#define DEFAULT_SYMBOL "R_FUZZY_HASH"
#define DEFAULT_UPSTREAM_ERROR_TIME 10
static void fuzzy_symbol_callback (struct rspamd_task *task, void *unused);
/* Initialization */
-gint fuzzy_check_module_init (struct rspamd_config *cfg, struct module_ctx **ctx);
+gint fuzzy_check_module_init (struct rspamd_config *cfg,
+ struct module_ctx **ctx);
gint fuzzy_check_module_config (struct rspamd_config *cfg);
gint fuzzy_check_module_reconfig (struct rspamd_config *cfg);
-static gint fuzzy_attach_controller (struct module_ctx *ctx, GHashTable *commands);
+static gint fuzzy_attach_controller (struct module_ctx *ctx,
+ GHashTable *commands);
module_t fuzzy_check_module = {
"fuzzy_check",
};
static void
-parse_flags (struct fuzzy_rule *rule, struct rspamd_config *cfg, const ucl_object_t *val)
+parse_flags (struct fuzzy_rule *rule,
+ struct rspamd_config *cfg,
+ const ucl_object_t *val)
{
const ucl_object_t *elt;
struct fuzzy_mapping *map;
const gchar *sym = NULL;
if (val->type == UCL_STRING) {
- msg_err ("string mappings are deprecated and no longer supported, use new style configuration");
+ msg_err (
+ "string mappings are deprecated and no longer supported, use new style configuration");
}
else if (val->type == UCL_OBJECT) {
elt = ucl_object_find_key (val, "symbol");
sym = ucl_object_key (val);
}
if (sym != NULL) {
- map = rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool, sizeof (struct fuzzy_mapping));
+ map =
+ rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool,
+ sizeof (struct fuzzy_mapping));
map->symbol = sym;
elt = ucl_object_find_key (val, "flag");
if (elt != NULL && ucl_obj_toint_safe (elt, &map->fuzzy_flag)) {
map->weight = rule->max_score;
}
/* Add flag to hash table */
- g_hash_table_insert (rule->mappings, GINT_TO_POINTER (map->fuzzy_flag), map);
+ g_hash_table_insert (rule->mappings,
+ GINT_TO_POINTER (map->fuzzy_flag), map);
register_virtual_symbol (&cfg->cache, map->symbol, 1.0);
}
else {
static GList *
parse_mime_types (const gchar *str)
{
- gchar **strvec, *p;
- gint num, i;
- struct fuzzy_mime_type *type;
- GList *res = NULL;
+ gchar **strvec, *p;
+ gint num, i;
+ struct fuzzy_mime_type *type;
+ GList *res = NULL;
strvec = g_strsplit_set (str, ",", 0);
num = g_strv_length (strvec);
g_strstrip (strvec[i]);
if ((p = strchr (strvec[i], '/')) != NULL) {
*p = 0;
- type = rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool, sizeof (struct fuzzy_mime_type));
- type->type = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool, strvec[i]);
- type->subtype = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool, p + 1);
+ type =
+ rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool,
+ sizeof (struct fuzzy_mime_type));
+ type->type = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool,
+ strvec[i]);
+ type->subtype = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool,
+ p + 1);
res = g_list_prepend (res, type);
}
else {
}
if (res != NULL) {
- rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool, (rspamd_mempool_destruct_t)g_list_free, res);
+ rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool,
+ (rspamd_mempool_destruct_t)g_list_free, res);
}
return res;
static gboolean
fuzzy_check_content_type (struct fuzzy_rule *rule, GMimeContentType *type)
{
- struct fuzzy_mime_type *ft;
- GList *cur;
+ struct fuzzy_mime_type *ft;
+ GList *cur;
cur = rule->mime_types;
while (cur) {
static void
parse_servers_string (struct fuzzy_rule *rule, const gchar *str)
{
- gchar **strvec;
- gint i, num;
- struct storage_server *cur;
+ gchar **strvec;
+ gint i, num;
+ struct storage_server *cur;
strvec = g_strsplit_set (str, ",", 0);
num = g_strv_length (strvec);
- rule->servers = rspamd_mempool_alloc0 (fuzzy_module_ctx->fuzzy_pool, sizeof (struct storage_server) * num);
+ rule->servers = rspamd_mempool_alloc0 (fuzzy_module_ctx->fuzzy_pool,
+ sizeof (struct storage_server) * num);
for (i = 0; i < num; i++) {
g_strstrip (strvec[i]);
cur = &rule->servers[rule->servers_num];
- if (rspamd_parse_host_port (fuzzy_module_ctx->fuzzy_pool, strvec[i], &cur->addr, &cur->port)) {
+ if (rspamd_parse_host_port (fuzzy_module_ctx->fuzzy_pool, strvec[i],
+ &cur->addr, &cur->port)) {
if (cur->port == 0) {
cur->port = DEFAULT_PORT;
}
- cur->name = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool, strvec[i]);
+ cur->name = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool,
+ strvec[i]);
rule->servers_num++;
}
}
{
static gchar strbuf [FUZZY_HASHLEN * 2 + 1];
const int max_print = 5;
- gint i;
+ gint i;
guint8 byte;
- for (i = 0; i < max_print; i ++) {
+ for (i = 0; i < max_print; i++) {
byte = h->hash_pipe[i];
if (byte == '\0') {
break;
rule->mappings = g_hash_table_new (g_direct_hash, g_direct_equal);
rule->symbol = default_symbol;
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t)g_hash_table_unref, rule->mappings);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t)g_hash_table_unref,
+ rule->mappings);
rule->read_only = FALSE;
return rule;
return -1;
}
- rule = fuzzy_rule_new (fuzzy_module_ctx->default_symbol, fuzzy_module_ctx->fuzzy_pool);
+ rule = fuzzy_rule_new (fuzzy_module_ctx->default_symbol,
+ fuzzy_module_ctx->fuzzy_pool);
if ((value = ucl_object_find_key (obj, "mime_types")) != NULL) {
if (value->type == UCL_ARRAY) {
value = value->value.av;
}
- LL_FOREACH (value, cur) {
+ LL_FOREACH (value, cur)
+ {
rule->mime_types = g_list_concat (rule->mime_types,
parse_mime_types (ucl_obj_tostring (cur)));
}
if (value->type == UCL_ARRAY) {
value = value->value.av;
}
- LL_FOREACH (value, cur) {
+ LL_FOREACH (value, cur)
+ {
parse_servers_string (rule, ucl_obj_tostring (cur));
}
}
}
if (rule->servers_num == 0) {
- msg_err ("no servers defined for fuzzy rule with symbol: %s", rule->symbol);
+ msg_err ("no servers defined for fuzzy rule with symbol: %s",
+ rule->symbol);
return -1;
}
else {
- fuzzy_module_ctx->fuzzy_rules = g_list_prepend (fuzzy_module_ctx->fuzzy_rules, rule);
+ fuzzy_module_ctx->fuzzy_rules = g_list_prepend (
+ fuzzy_module_ctx->fuzzy_rules,
+ rule);
if (rule->symbol != fuzzy_module_ctx->default_symbol) {
register_virtual_symbol (&cfg->cache, rule->symbol, 1.0);
}
{
fuzzy_module_ctx = g_malloc0 (sizeof (struct fuzzy_ctx));
- fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
fuzzy_module_ctx->cfg = cfg;
*ctx = (struct module_ctx *)fuzzy_module_ctx;
gint
fuzzy_check_module_config (struct rspamd_config *cfg)
{
- const ucl_object_t *value, *cur;
- gint res = TRUE;
+ const ucl_object_t *value, *cur;
+ gint res = TRUE;
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "symbol")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check", "symbol")) != NULL) {
fuzzy_module_ctx->default_symbol = ucl_obj_tostring (value);
}
else {
fuzzy_module_ctx->default_symbol = DEFAULT_SYMBOL;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_length")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check",
+ "min_length")) != NULL) {
fuzzy_module_ctx->min_hash_len = ucl_obj_toint (value);
}
else {
fuzzy_module_ctx->min_hash_len = 0;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_bytes")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check",
+ "min_bytes")) != NULL) {
fuzzy_module_ctx->min_bytes = ucl_obj_toint (value);
}
else {
fuzzy_module_ctx->min_bytes = 0;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_height")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check",
+ "min_height")) != NULL) {
fuzzy_module_ctx->min_height = ucl_obj_toint (value);
}
else {
fuzzy_module_ctx->min_height = 0;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_width")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check",
+ "min_width")) != NULL) {
fuzzy_module_ctx->min_width = ucl_obj_toint (value);
}
else {
fuzzy_module_ctx->min_width = 0;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "timeout")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check", "timeout")) != NULL) {
fuzzy_module_ctx->io_timeout = ucl_obj_todouble (value) * 1000;
}
else {
fuzzy_module_ctx->io_timeout = DEFAULT_IO_TIMEOUT;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "whitelist")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check",
+ "whitelist")) != NULL) {
fuzzy_module_ctx->whitelist = radix_tree_create ();
if (!add_map (cfg, ucl_obj_tostring (value),
- "Fuzzy whitelist", read_radix_list, fin_radix_list,
- (void **)&fuzzy_module_ctx->whitelist)) {
+ "Fuzzy whitelist", read_radix_list, fin_radix_list,
+ (void **)&fuzzy_module_ctx->whitelist)) {
msg_err ("cannot add whitelist '%s'", ucl_obj_tostring (value));
}
}
fuzzy_module_ctx->whitelist = NULL;
}
- if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "rule")) != NULL) {
- LL_FOREACH (value, cur) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "fuzzy_check", "rule")) != NULL) {
+ LL_FOREACH (value, cur)
+ {
if (fuzzy_parse_rule (cfg, cur) == -1) {
return -1;
}
if (fuzzy_module_ctx->fuzzy_rules != NULL) {
register_callback_symbol (&cfg->cache, fuzzy_module_ctx->default_symbol,
- 1.0, fuzzy_symbol_callback, NULL);
+ 1.0, fuzzy_symbol_callback, NULL);
}
else {
msg_warn ("fuzzy module is enabled but no rules are defined");
{
rspamd_mempool_delete (fuzzy_module_ctx->fuzzy_pool);
- fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
fuzzy_module_ctx->cfg = cfg;
-
+
return fuzzy_check_module_config (cfg);
}
static void
fuzzy_io_fin (void *ud)
{
- struct fuzzy_client_session *session = ud;
+ struct fuzzy_client_session *session = ud;
event_del (&session->ev);
close (session->fd);
static void
fuzzy_io_callback (gint fd, short what, void *arg)
{
- struct fuzzy_client_session *session = arg;
- struct fuzzy_cmd cmd;
- struct fuzzy_mapping *map;
- gchar buf[62], *err_str;
- const gchar *symbol;
- gint value = 0, flag = 0, r;
- double nval;
+ struct fuzzy_client_session *session = arg;
+ struct fuzzy_cmd cmd;
+ struct fuzzy_mapping *map;
+ gchar buf[62], *err_str;
+ const gchar *symbol;
+ gint value = 0, flag = 0, r;
+ double nval;
if (what == EV_WRITE) {
/* Send command to storage */
}
*err_str = '\0';
/* Get mapping by flag */
- if ((map = g_hash_table_lookup (session->rule->mappings, GINT_TO_POINTER (flag))) == NULL) {
+ if ((map =
+ g_hash_table_lookup (session->rule->mappings,
+ GINT_TO_POINTER (flag))) == NULL) {
/* Default symbol and default weight */
symbol = session->rule->symbol;
nval = fuzzy_normalize (value, session->rule->max_score);
symbol = map->symbol;
nval = fuzzy_normalize (value, map->weight);
}
- msg_info ("<%s>, found fuzzy hash '%s' with weight: %.2f, in list: %s:%d%s",
- session->task->message_id, fuzzy_to_string (session->h), nval, symbol,
- flag, map == NULL ? "(unknown)" : "");
+ msg_info (
+ "<%s>, found fuzzy hash '%s' with weight: %.2f, in list: %s:%d%s",
+ session->task->message_id,
+ fuzzy_to_string (session->h),
+ nval,
+ symbol,
+ flag,
+ map == NULL ? "(unknown)" : "");
if (map != NULL || !session->rule->skip_unknown) {
- rspamd_snprintf (buf, sizeof (buf), "%d: %d / %.2f", flag, value, nval);
- insert_result_single (session->task, symbol, nval, g_list_prepend (NULL,
- rspamd_mempool_strdup (session->task->task_pool, buf)));
+ rspamd_snprintf (buf,
+ sizeof (buf),
+ "%d: %d / %.2f",
+ flag,
+ value,
+ nval);
+ insert_result_single (session->task,
+ symbol,
+ nval,
+ g_list_prepend (NULL,
+ rspamd_mempool_strdup (session->task->task_pool, buf)));
}
}
goto ok;
}
else {
errno = ETIMEDOUT;
- goto err;
+ goto err;
}
return;
- err:
- msg_err ("got error on IO with server %s, %d, %s", session->server->name, errno, strerror (errno));
- ok:
+err:
+ msg_err ("got error on IO with server %s, %d, %s",
+ session->server->name,
+ errno,
+ strerror (errno));
+ok:
remove_normal_event (session->task->s, fuzzy_io_fin, session);
}
static void
fuzzy_learn_callback (gint fd, short what, void *arg)
{
- struct fuzzy_learn_session *session = arg;
- struct fuzzy_cmd cmd;
- gchar buf[512];
- const gchar *cmd_name;
+ struct fuzzy_learn_session *session = arg;
+ struct fuzzy_cmd cmd;
+ gchar buf[512];
+ const gchar *cmd_name;
cmd_name = (session->cmd == FUZZY_WRITE ? "add" : "delete");
if (what == EV_WRITE) {
if (write (fd, &cmd, sizeof (struct fuzzy_cmd)) == -1) {
if (*(session->err) == NULL) {
g_set_error (session->err,
- g_quark_from_static_string ("fuzzy check"),
- errno, "write socket error: %s", strerror (errno));
+ g_quark_from_static_string ("fuzzy check"),
+ errno, "write socket error: %s", strerror (errno));
}
goto err;
}
else {
event_del (&session->ev);
- event_set (&session->ev, fd, EV_READ, fuzzy_learn_callback, session);
+ event_set (&session->ev, fd, EV_READ, fuzzy_learn_callback,
+ session);
event_add (&session->ev, &session->tv);
}
}
else if (what == EV_READ) {
if (read (fd, buf, sizeof (buf)) == -1) {
- msg_info ("cannot %s fuzzy hash for message <%s>, list %s:%d", cmd_name,
- session->task->message_id, session->rule->symbol, session->flag);
+ msg_info ("cannot %s fuzzy hash for message <%s>, list %s:%d",
+ cmd_name,
+ session->task->message_id,
+ session->rule->symbol,
+ session->flag);
if (*(session->err) == NULL) {
g_set_error (session->err,
- g_quark_from_static_string ("fuzzy check"),
- errno, "read socket error: %s", strerror (errno));
+ g_quark_from_static_string ("fuzzy check"),
+ errno, "read socket error: %s", strerror (errno));
}
goto err;
}
else if (buf[0] == 'O' && buf[1] == 'K') {
- msg_info ("%s fuzzy hash '%s', list: %s:%d for message <%s>", cmd_name,
- fuzzy_to_string (session->h), session->rule->symbol,
- session->flag, session->task->message_id);
+ msg_info ("%s fuzzy hash '%s', list: %s:%d for message <%s>",
+ cmd_name,
+ fuzzy_to_string (session->h),
+ session->rule->symbol,
+ session->flag,
+ session->task->message_id);
goto ok;
}
else {
- msg_info ("cannot %s fuzzy hash '%s' for message <%s>, list %s:%d", cmd_name,
- fuzzy_to_string (session->h), session->task->message_id,
- session->rule->symbol, session->flag);
+ msg_info ("cannot %s fuzzy hash '%s' for message <%s>, list %s:%d",
+ cmd_name,
+ fuzzy_to_string (session->h),
+ session->task->message_id,
+ session->rule->symbol,
+ session->flag);
if (*(session->err) == NULL) {
g_set_error (session->err,
- g_quark_from_static_string ("fuzzy check"), EINVAL, "%s fuzzy error", cmd_name);
+ g_quark_from_static_string (
+ "fuzzy check"), EINVAL, "%s fuzzy error", cmd_name);
}
goto ok;
}
errno = ETIMEDOUT;
if (*(session->err) == NULL) {
g_set_error (session->err,
- g_quark_from_static_string ("fuzzy check"), EINVAL, "%s fuzzy, IO timeout", cmd_name);
+ g_quark_from_static_string (
+ "fuzzy check"), EINVAL, "%s fuzzy, IO timeout", cmd_name);
}
- goto err;
+ goto err;
}
return;
err:
msg_err ("got error in IO with server %s, %d, %s",
- session->server->name, errno, strerror (errno));
+ session->server->name, errno, strerror (errno));
rspamd_http_connection_unref (session->http_entry->conn);
rspamd_task_free (session->task, TRUE);
event_del (&session->ev);
if (--(*(session->saved)) == 0) {
if (*(session->err) != NULL) {
rspamd_controller_send_error (session->http_entry,
- (*session->err)->code, (*session->err)->message);
+ (*session->err)->code, (*session->err)->message);
g_error_free (*session->err);
}
else {
rspamd_controller_send_string (session->http_entry,
- "{\"success\":true}");
+ "{\"success\":true}");
}
}
}
static inline void
-register_fuzzy_call (struct rspamd_task *task, struct fuzzy_rule *rule, fuzzy_hash_t *h)
+register_fuzzy_call (struct rspamd_task *task,
+ struct fuzzy_rule *rule,
+ fuzzy_hash_t *h)
{
- struct fuzzy_client_session *session;
- struct storage_server *selected;
- gint sock;
+ struct fuzzy_client_session *session;
+ struct storage_server *selected;
+ gint sock;
/* Get upstream */
#ifdef HAVE_CLOCK_GETTIME
- selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
- sizeof (struct storage_server), task->ts.tv_sec,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
- h->hash_pipe, sizeof (h->hash_pipe));
+ selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
+ rule->servers_num,
+ sizeof (struct storage_server),
+ task->ts.tv_sec,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS,
+ h->hash_pipe,
+ sizeof (h->hash_pipe));
#else
- selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
- sizeof (struct storage_server), task->tv.tv_sec,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS, h->hash_pipe, sizeof (h->hash_pipe));
+ selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
+ rule->servers_num,
+ sizeof (struct storage_server),
+ task->tv.tv_sec,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS,
+ h->hash_pipe,
+ sizeof (h->hash_pipe));
#endif
if (selected) {
- if ((sock = make_universal_socket (selected->addr, selected->port, SOCK_DGRAM, TRUE, FALSE, FALSE)) == -1) {
- msg_warn ("cannot connect to %s, %d, %s", selected->name, errno, strerror (errno));
+ if ((sock =
+ make_universal_socket (selected->addr, selected->port, SOCK_DGRAM,
+ TRUE, FALSE, FALSE)) == -1) {
+ msg_warn ("cannot connect to %s, %d, %s",
+ selected->name,
+ errno,
+ strerror (errno));
}
else {
/* Create session for a socket */
- session = rspamd_mempool_alloc (task->task_pool, sizeof (struct fuzzy_client_session));
- event_set (&session->ev, sock, EV_WRITE, fuzzy_io_callback, session);
+ session =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct fuzzy_client_session));
+ event_set (&session->ev, sock, EV_WRITE, fuzzy_io_callback,
+ session);
msec_to_tv (fuzzy_module_ctx->io_timeout, &session->tv);
session->state = 0;
session->h = h;
session->server = selected;
session->rule = rule;
event_add (&session->ev, &session->tv);
- register_async_event (task->s, fuzzy_io_fin, session, g_quark_from_static_string ("fuzzy check"));
+ register_async_event (task->s,
+ fuzzy_io_fin,
+ session,
+ g_quark_from_static_string ("fuzzy check"));
}
}
}
static void
fuzzy_check_rule (struct rspamd_task *task, struct fuzzy_rule *rule)
{
- struct mime_text_part *part;
- struct mime_part *mime_part;
- struct rspamd_image *image;
- gchar *checksum;
- gsize hashlen;
- GList *cur;
- fuzzy_hash_t *fake_fuzzy;
+ struct mime_text_part *part;
+ struct mime_part *mime_part;
+ struct rspamd_image *image;
+ gchar *checksum;
+ gsize hashlen;
+ GList *cur;
+ fuzzy_hash_t *fake_fuzzy;
cur = task->text_parts;
/* Check length of part */
if (fuzzy_module_ctx->min_bytes > part->content->len) {
msg_info ("<%s>, part is shorter than %d symbols, skip fuzzy check",
- task->message_id, fuzzy_module_ctx->min_bytes);
+ task->message_id, fuzzy_module_ctx->min_bytes);
cur = g_list_next (cur);
continue;
}
hashlen = strlen (part->fuzzy->hash_pipe);
if (hashlen == 0) {
msg_info ("<%s>, part hash empty, skip fuzzy check",
- task->message_id, fuzzy_module_ctx->min_hash_len);
+ task->message_id, fuzzy_module_ctx->min_hash_len);
cur = g_list_next (cur);
continue;
}
if (fuzzy_module_ctx->min_hash_len != 0 &&
- hashlen * part->fuzzy->block_size < fuzzy_module_ctx->min_hash_len) {
- msg_info ("<%s>, part hash is shorter than %d symbols, skip fuzzy check",
- task->message_id, fuzzy_module_ctx->min_hash_len);
+ hashlen * part->fuzzy->block_size <
+ fuzzy_module_ctx->min_hash_len) {
+ msg_info (
+ "<%s>, part hash is shorter than %d symbols, skip fuzzy check",
+ task->message_id,
+ fuzzy_module_ctx->min_hash_len);
cur = g_list_next (cur);
continue;
}
while (cur) {
image = cur->data;
if (image->data->len > 0) {
- if (fuzzy_module_ctx->min_height <= 0 || image->height >= fuzzy_module_ctx->min_height) {
- if (fuzzy_module_ctx->min_width <= 0 || image->width >= fuzzy_module_ctx->min_width) {
- checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5, image->data->data, image->data->len);
+ if (fuzzy_module_ctx->min_height <= 0 || image->height >=
+ fuzzy_module_ctx->min_height) {
+ if (fuzzy_module_ctx->min_width <= 0 || image->width >=
+ fuzzy_module_ctx->min_width) {
+ checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
+ image->data->data,
+ image->data->len);
/* Construct fake fuzzy hash */
- fake_fuzzy = rspamd_mempool_alloc0 (task->task_pool, sizeof (fuzzy_hash_t));
- rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum, sizeof (fake_fuzzy->hash_pipe));
+ fake_fuzzy = rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (fuzzy_hash_t));
+ rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum,
+ sizeof (fake_fuzzy->hash_pipe));
register_fuzzy_call (task, rule, fake_fuzzy);
g_free (checksum);
}
cur = task->parts;
while (cur) {
mime_part = cur->data;
- if (mime_part->content->len > 0 && fuzzy_check_content_type (rule, mime_part->type)) {
- if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >= fuzzy_module_ctx->min_bytes) {
- checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
- mime_part->content->data, mime_part->content->len);
- /* Construct fake fuzzy hash */
- fake_fuzzy = rspamd_mempool_alloc0 (task->task_pool, sizeof (fuzzy_hash_t));
- rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum, sizeof (fake_fuzzy->hash_pipe));
- register_fuzzy_call (task, rule, fake_fuzzy);
- g_free (checksum);
+ if (mime_part->content->len > 0 &&
+ fuzzy_check_content_type (rule, mime_part->type)) {
+ if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >=
+ fuzzy_module_ctx->min_bytes) {
+ checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
+ mime_part->content->data, mime_part->content->len);
+ /* Construct fake fuzzy hash */
+ fake_fuzzy =
+ rspamd_mempool_alloc0 (task->task_pool,
+ sizeof (fuzzy_hash_t));
+ rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum,
+ sizeof (fake_fuzzy->hash_pipe));
+ register_fuzzy_call (task, rule, fake_fuzzy);
+ g_free (checksum);
}
}
cur = g_list_next (cur);
/* Check whitelist */
if (fuzzy_module_ctx->whitelist && task->from_addr.af == AF_INET) {
if (radix32tree_find (fuzzy_module_ctx->whitelist,
- ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) != RADIX_NO_VALUE) {
+ ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) !=
+ RADIX_NO_VALUE) {
msg_info ("<%s>, address %s is whitelisted, skip fuzzy check",
- task->message_id, rspamd_inet_address_to_string (&task->from_addr));
+ task->message_id,
+ rspamd_inet_address_to_string (&task->from_addr));
return;
}
}
static inline gboolean
register_fuzzy_controller_call (struct rspamd_http_connection_entry *entry,
- struct fuzzy_rule *rule, struct rspamd_task *task, fuzzy_hash_t *h,
- gint cmd, gint value, gint flag, gint *saved, GError **err)
+ struct fuzzy_rule *rule, struct rspamd_task *task, fuzzy_hash_t *h,
+ gint cmd, gint value, gint flag, gint *saved, GError **err)
{
- struct fuzzy_learn_session *s;
- struct storage_server *selected;
- gint sock;
+ struct fuzzy_learn_session *s;
+ struct storage_server *selected;
+ gint sock;
/* Get upstream */
#ifdef HAVE_CLOCK_GETTIME
- selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
- sizeof (struct storage_server), task->ts.tv_sec,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
- h->hash_pipe, sizeof (h->hash_pipe));
+ selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
+ rule->servers_num,
+ sizeof (struct storage_server),
+ task->ts.tv_sec,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS,
+ h->hash_pipe,
+ sizeof (h->hash_pipe));
#else
- selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
- sizeof (struct storage_server), task->tv.tv_sec,
- DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
- h->hash_pipe, sizeof (h->hash_pipe));
+ selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
+ rule->servers_num,
+ sizeof (struct storage_server),
+ task->tv.tv_sec,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS,
+ h->hash_pipe,
+ sizeof (h->hash_pipe));
#endif
if (selected) {
/* Create UDP socket */
if ((sock = make_universal_socket (selected->addr, selected->port,
- SOCK_DGRAM, TRUE, FALSE, FALSE)) == -1) {
+ SOCK_DGRAM, TRUE, FALSE, FALSE)) == -1) {
return FALSE;
}
else {
/* Socket is made, create session */
- s = rspamd_mempool_alloc (task->task_pool, sizeof (struct fuzzy_learn_session));
+ s =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct fuzzy_learn_session));
event_set (&s->ev, sock, EV_WRITE, fuzzy_learn_callback, s);
event_base_set (entry->rt->ev_base, &s->ev);
msec_to_tv (fuzzy_module_ctx->io_timeout, &s->tv);
s->task = task;
- s->h = rspamd_mempool_alloc (task->task_pool, sizeof (fuzzy_hash_t));
+ s->h =
+ rspamd_mempool_alloc (task->task_pool, sizeof (fuzzy_hash_t));
memcpy (s->h, h, sizeof (fuzzy_hash_t));
- s->http_entry =entry;
+ s->http_entry = entry;
s->server = selected;
s->cmd = cmd;
s->value = value;
}
static int
-fuzzy_process_rule (struct rspamd_http_connection_entry *entry, struct fuzzy_rule *rule,
- struct rspamd_task *task, GError **err, gint cmd, gint flag, gint value, gint *saved)
+fuzzy_process_rule (struct rspamd_http_connection_entry *entry,
+ struct fuzzy_rule *rule,
+ struct rspamd_task *task,
+ GError **err,
+ gint cmd,
+ gint flag,
+ gint value,
+ gint *saved)
{
- struct mime_text_part *part;
- struct mime_part *mime_part;
- struct rspamd_image *image;
- GList *cur;
- gchar *checksum;
- fuzzy_hash_t fake_fuzzy;
- gint processed = 0;
+ struct mime_text_part *part;
+ struct mime_part *mime_part;
+ struct rspamd_image *image;
+ GList *cur;
+ gchar *checksum;
+ fuzzy_hash_t fake_fuzzy;
+ gint processed = 0;
/* Plan new event for writing */
cur = task->text_parts;
while (cur) {
part = cur->data;
- if (part->is_empty || part->fuzzy == NULL || part->fuzzy->hash_pipe[0] == '\0' ||
- (fuzzy_module_ctx->min_bytes > 0 && part->content->len < fuzzy_module_ctx->min_bytes)) {
+ if (part->is_empty || part->fuzzy == NULL ||
+ part->fuzzy->hash_pipe[0] == '\0' ||
+ (fuzzy_module_ctx->min_bytes > 0 && part->content->len <
+ fuzzy_module_ctx->min_bytes)) {
/* Skip empty parts */
cur = g_list_next (cur);
continue;
}
- if (! register_fuzzy_controller_call (entry, rule, task,
- part->fuzzy, cmd, value, flag, saved, err)) {
+ if (!register_fuzzy_controller_call (entry, rule, task,
+ part->fuzzy, cmd, value, flag, saved, err)) {
goto err;
}
- if (! register_fuzzy_controller_call (entry, rule, task,
- part->double_fuzzy, cmd, value, flag, saved, err)) {
+ if (!register_fuzzy_controller_call (entry, rule, task,
+ part->double_fuzzy, cmd, value, flag, saved, err)) {
/* Cannot write hash */
goto err;
}
- processed ++;
+ processed++;
cur = g_list_next (cur);
}
while (cur) {
image = cur->data;
if (image->data->len > 0) {
- if (fuzzy_module_ctx->min_height <= 0 || image->height >= fuzzy_module_ctx->min_height) {
- if (fuzzy_module_ctx->min_width <= 0 || image->width >= fuzzy_module_ctx->min_width) {
- checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5, image->data->data, image->data->len);
+ if (fuzzy_module_ctx->min_height <= 0 || image->height >=
+ fuzzy_module_ctx->min_height) {
+ if (fuzzy_module_ctx->min_width <= 0 || image->width >=
+ fuzzy_module_ctx->min_width) {
+ checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
+ image->data->data,
+ image->data->len);
/* Construct fake fuzzy hash */
fake_fuzzy.block_size = 0;
- memset (fake_fuzzy.hash_pipe, 0, sizeof (fake_fuzzy.hash_pipe));
- rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum, sizeof (fake_fuzzy.hash_pipe));
- if (! register_fuzzy_controller_call (entry, rule, task,
- &fake_fuzzy, cmd, value, flag, saved, err)) {
+ memset (fake_fuzzy.hash_pipe, 0,
+ sizeof (fake_fuzzy.hash_pipe));
+ rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum,
+ sizeof (fake_fuzzy.hash_pipe));
+ if (!register_fuzzy_controller_call (entry, rule, task,
+ &fake_fuzzy, cmd, value, flag, saved, err)) {
g_free (checksum);
goto err;
}
- msg_info ("save hash of image: [%s] to list: %d", checksum, flag);
+ msg_info ("save hash of image: [%s] to list: %d",
+ checksum,
+ flag);
g_free (checksum);
- processed ++;
+ processed++;
}
}
}
cur = task->parts;
while (cur) {
mime_part = cur->data;
- if (mime_part->content->len > 0 && fuzzy_check_content_type (rule, mime_part->type)) {
- if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >= fuzzy_module_ctx->min_bytes) {
+ if (mime_part->content->len > 0 &&
+ fuzzy_check_content_type (rule, mime_part->type)) {
+ if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >=
+ fuzzy_module_ctx->min_bytes) {
checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
mime_part->content->data, mime_part->content->len);
/* Construct fake fuzzy hash */
fake_fuzzy.block_size = 0;
memset (fake_fuzzy.hash_pipe, 0, sizeof (fake_fuzzy.hash_pipe));
- rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum, sizeof (fake_fuzzy.hash_pipe));
- if (! register_fuzzy_controller_call (entry, rule, task,
- &fake_fuzzy, cmd, value, flag, saved, err)) {
+ rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum,
+ sizeof (fake_fuzzy.hash_pipe));
+ if (!register_fuzzy_controller_call (entry, rule, task,
+ &fake_fuzzy, cmd, value, flag, saved, err)) {
goto err;
}
msg_info ("save hash of part of type: %s/%s: [%s] to list %d",
- mime_part->type->type, mime_part->type->subtype,
- checksum, flag);
+ mime_part->type->type, mime_part->type->subtype,
+ checksum, flag);
g_free (checksum);
- processed ++;
+ processed++;
}
}
cur = g_list_next (cur);
static void
fuzzy_process_handler (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg, gint cmd, gint value, gint flag,
- struct fuzzy_ctx *ctx)
+ struct rspamd_http_message *msg, gint cmd, gint value, gint flag,
+ struct fuzzy_ctx *ctx)
{
struct fuzzy_rule *rule;
gboolean processed = FALSE, res = TRUE;
if (r == -1) {
msg_warn ("cannot process message for fuzzy");
rspamd_task_free (task, FALSE);
- rspamd_controller_send_error (conn_ent, 400, "Message processing error");
+ rspamd_controller_send_error (conn_ent, 400,
+ "Message processing error");
return;
}
cur = fuzzy_module_ctx->fuzzy_rules;
}
/* Check for flag */
- if (g_hash_table_lookup (rule->mappings, GINT_TO_POINTER (flag)) == NULL) {
+ if (g_hash_table_lookup (rule->mappings,
+ GINT_TO_POINTER (flag)) == NULL) {
cur = g_list_next (cur);
continue;
}
static gboolean
fuzzy_controller_handler (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg, struct module_ctx *ctx, gint cmd)
+ struct rspamd_http_message *msg, struct module_ctx *ctx, gint cmd)
{
const gchar *arg;
gchar *err_str;
- gint value = 1, flag = 0;
+ gint value = 1, flag = 0;
/* Get size */
arg = rspamd_http_message_find_header (msg, "Value");
}
fuzzy_process_handler (conn_ent, msg, cmd, value, flag,
- (struct fuzzy_ctx *)ctx);
+ (struct fuzzy_ctx *)ctx);
return 0;
}
static gboolean
fuzzy_add_handler (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg, struct module_ctx *ctx)
+ struct rspamd_http_message *msg, struct module_ctx *ctx)
{
return fuzzy_controller_handler (conn_ent, msg,
- ctx, FUZZY_WRITE);
+ ctx, FUZZY_WRITE);
}
static gboolean
fuzzy_delete_handler (struct rspamd_http_connection_entry *conn_ent,
- struct rspamd_http_message *msg, struct module_ctx *ctx)
+ struct rspamd_http_message *msg, struct module_ctx *ctx)
{
return fuzzy_controller_handler (conn_ent, msg,
- ctx, FUZZY_DEL);
+ ctx, FUZZY_DEL);
}
static int
*/
+#include "cfg_file.h"
#include "config.h"
+#include "expressions.h"
+#include "json/jansson.h"
+#include "lua/lua_common.h"
#include "main.h"
-#include "message.h"
-#include "cfg_file.h"
#include "map.h"
+#include "message.h"
#include "util.h"
-#include "expressions.h"
-#include "lua/lua_common.h"
-#include "json/jansson.h"
#define DEFAULT_STATFILE_PREFIX "./"
struct regexp_module_item {
- struct expression *expr;
- const gchar *symbol;
- guint32 avg_time;
- gpointer lua_function;
+ struct expression *expr;
+ const gchar *symbol;
+ guint32 avg_time;
+ gpointer lua_function;
};
struct autolearn_data {
- gchar *statfile_name;
- gchar *symbol;
- float weight;
+ gchar *statfile_name;
+ gchar *symbol;
+ float weight;
};
struct regexp_ctx {
- gint (*filter) (struct rspamd_task * task);
- GHashTable *autolearn_symbols;
- gchar *statfile_prefix;
-
- rspamd_mempool_t *regexp_pool;
- rspamd_mempool_t *dynamic_pool;
- gsize max_size;
- gsize max_threads;
- GThreadPool *workers;
+ gint (*filter) (struct rspamd_task * task);
+ GHashTable *autolearn_symbols;
+ gchar *statfile_prefix;
+
+ rspamd_mempool_t *regexp_pool;
+ rspamd_mempool_t *dynamic_pool;
+ gsize max_size;
+ gsize max_threads;
+ GThreadPool *workers;
};
struct regexp_json_buf {
- gchar *buf;
- gchar *pos;
- size_t buflen;
- struct rspamd_config *cfg;
+ gchar *buf;
+ gchar *pos;
+ size_t buflen;
+ struct rspamd_config *cfg;
};
/* Lua regexp module for checking rspamd regexps */
LUA_FUNCTION_DEF (regexp, match);
-static const struct luaL_reg regexplib_m[] = {
+static const struct luaL_reg regexplib_m[] = {
LUA_INTERFACE_DEF (regexp, match),
{"__tostring", lua_class_tostring},
{NULL, NULL}
};
-static struct regexp_ctx *regexp_module_ctx = NULL;
-static GMutex *workers_mtx = NULL;
-
-static gint regexp_common_filter (struct rspamd_task *task);
-static void process_regexp_item_threaded (gpointer data, gpointer user_data);
-static gboolean rspamd_regexp_match_number (struct rspamd_task *task, GList * args, void *unused);
-static gboolean rspamd_raw_header_exists (struct rspamd_task *task, GList * args, void *unused);
-static gboolean rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused);
-static gboolean rspamd_regexp_occurs_number (struct rspamd_task *task, GList * args, void *unused);
-static gboolean rspamd_content_type_is_type (struct rspamd_task * task, GList * args, void *unused);
-static gboolean rspamd_content_type_is_subtype (struct rspamd_task *task, GList * args, void *unused);
-static gboolean rspamd_content_type_has_param (struct rspamd_task * task, GList * args, void *unused);
-static gboolean rspamd_content_type_compare_param (struct rspamd_task * task, GList * args, void *unused);
-static gboolean rspamd_has_content_part (struct rspamd_task *task, GList * args, void *unused);
-static gboolean rspamd_has_content_part_len (struct rspamd_task *task, GList * args, void *unused);
-static void process_regexp_item (struct rspamd_task *task, void *user_data);
+static struct regexp_ctx *regexp_module_ctx = NULL;
+static GMutex *workers_mtx = NULL;
+
+static gint regexp_common_filter (struct rspamd_task *task);
+static void process_regexp_item_threaded (gpointer data, gpointer user_data);
+static gboolean rspamd_regexp_match_number (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_raw_header_exists (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_check_smtp_data (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_regexp_occurs_number (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_content_type_is_type (struct rspamd_task * task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_content_type_is_subtype (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_content_type_has_param (struct rspamd_task * task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_content_type_compare_param (struct rspamd_task * task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_has_content_part (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static gboolean rspamd_has_content_part_len (struct rspamd_task *task,
+ GList * args,
+ void *unused);
+static void process_regexp_item (struct rspamd_task *task, void *user_data);
/* Initialization */
/* Task cache functions */
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
-static GStaticMutex task_cache_mtx = G_STATIC_MUTEX_INIT;
+static GStaticMutex task_cache_mtx = G_STATIC_MUTEX_INIT;
#else
G_LOCK_DEFINE (task_cache_mtx);
#endif
void
-task_cache_add (struct rspamd_task *task, struct rspamd_regexp *re, gint32 result)
+task_cache_add (struct rspamd_task *task,
+ struct rspamd_regexp *re,
+ gint32 result)
{
if (result == 0) {
result = -1;
#else
G_LOCK (task_cache_mtx);
#endif
- g_hash_table_insert (task->re_cache, re->regexp_text, GINT_TO_POINTER (result));
+ g_hash_table_insert (task->re_cache, re->regexp_text,
+ GINT_TO_POINTER (result));
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
g_static_mutex_unlock (&task_cache_mtx);
#else
gint32
task_cache_check (struct rspamd_task *task, struct rspamd_regexp *re)
{
- gpointer res;
- gint32 r;
+ gpointer res;
+ gint32 r;
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
g_static_mutex_lock (&task_cache_mtx);
return 1;
}
-static void
+static void
regexp_dynamic_insert_result (struct rspamd_task *task, void *user_data)
{
- gchar *symbol = user_data;
-
+ gchar *symbol = user_data;
+
insert_result (task, symbol, 1, NULL);
}
static gboolean
parse_regexp_ipmask (const gchar *begin, struct dynamic_map_item *addr)
{
- const gchar *pos;
- gchar ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
- gint state = 0, dots = 0;
-
- bzero (ip_buf, sizeof (ip_buf));
+ const gchar *pos;
+ gchar ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
+ gint state = 0, dots = 0;
+
+ bzero (ip_buf, sizeof (ip_buf));
bzero (mask_buf, sizeof (mask_buf));
pos = begin;
p = ip_buf;
if (*pos == '!') {
addr->negative = TRUE;
- pos ++;
+ pos++;
}
else {
addr->negative = FALSE;
while (*pos) {
switch (state) {
- case 0:
- state = 1;
- p = ip_buf;
- dots = 0;
- break;
- case 1:
- /* Begin parse ip */
- if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
- return FALSE;
- }
- if (g_ascii_isdigit (*pos)) {
- *p ++ = *pos ++;
- }
- else if (*pos == '.') {
- *p ++ = *pos ++;
- dots ++;
- }
- else if (*pos == '/') {
- pos ++;
- p = mask_buf;
- state = 2;
- }
- else {
- /* Invalid character */
- return FALSE;
- }
- break;
- case 2:
- /* Parse mask */
- if (p - mask_buf > 2) {
- return FALSE;
- }
- if (g_ascii_isdigit (*pos)) {
- *p ++ = *pos ++;
- }
- else {
- return FALSE;
- }
- break;
+ case 0:
+ state = 1;
+ p = ip_buf;
+ dots = 0;
+ break;
+ case 1:
+ /* Begin parse ip */
+ if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
+ return FALSE;
+ }
+ if (g_ascii_isdigit (*pos)) {
+ *p++ = *pos++;
+ }
+ else if (*pos == '.') {
+ *p++ = *pos++;
+ dots++;
+ }
+ else if (*pos == '/') {
+ pos++;
+ p = mask_buf;
+ state = 2;
+ }
+ else {
+ /* Invalid character */
+ return FALSE;
+ }
+ break;
+ case 2:
+ /* Parse mask */
+ if (p - mask_buf > 2) {
+ return FALSE;
+ }
+ if (g_ascii_isdigit (*pos)) {
+ *p++ = *pos++;
+ }
+ else {
+ return FALSE;
+ }
+ break;
}
}
}
/* Process regexp expression */
-static gboolean
-read_regexp_expression (rspamd_mempool_t * pool, struct regexp_module_item *chain,
- const gchar *symbol, const gchar *line, gboolean raw_mode)
+static gboolean
+read_regexp_expression (rspamd_mempool_t * pool,
+ struct regexp_module_item *chain,
+ const gchar *symbol,
+ const gchar *line,
+ gboolean raw_mode)
{
- struct expression *e, *cur;
+ struct expression *e, *cur;
e = parse_expression (pool, (gchar *)line);
if (e == NULL) {
cur = e;
while (cur) {
if (cur->type == EXPR_REGEXP) {
- cur->content.operand = parse_regexp (pool, cur->content.operand, raw_mode);
+ cur->content.operand = parse_regexp (pool,
+ cur->content.operand,
+ raw_mode);
if (cur->content.operand == NULL) {
- msg_warn ("cannot parse regexp, skip expression %s = \"%s\"", symbol, line);
+ msg_warn ("cannot parse regexp, skip expression %s = \"%s\"",
+ symbol,
+ line);
return FALSE;
}
cur->type = EXPR_REGEXP_PARSED;
/* Callbacks for reading json dynamic rules */
-gchar *
-json_regexp_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+gchar *
+json_regexp_read_cb (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
- struct regexp_json_buf *jb;
- gint free, off;
+ struct regexp_json_buf *jb;
+ gint free, off;
if (data->cur_data == NULL) {
jb = g_malloc (sizeof (struct regexp_json_buf));
void
json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
{
- struct regexp_json_buf *jb;
- guint nelts, i, j;
- json_t *js, *cur_elt, *cur_nm, *it_val;
- json_error_t je;
- gchar *cur_rule, *cur_symbol;
- double score;
- struct regexp_module_item *cur_item;
- GList *cur_networks = NULL;
- struct dynamic_map_item *cur_nitem;
- rspamd_mempool_t *new_pool;
+ struct regexp_json_buf *jb;
+ guint nelts, i, j;
+ json_t *js, *cur_elt, *cur_nm, *it_val;
+ json_error_t je;
+ gchar *cur_rule, *cur_symbol;
+ double score;
+ struct regexp_module_item *cur_item;
+ GList *cur_networks = NULL;
+ struct dynamic_map_item *cur_nitem;
+ rspamd_mempool_t *new_pool;
if (data->prev_data) {
jb = data->prev_data;
js = json_loads (jb->buf, &je);
if (!js) {
- msg_err ("cannot load json data: parse error %s, on line %d", je.text, je.line);
+ msg_err ("cannot load json data: parse error %s, on line %d",
+ je.text,
+ je.line);
return;
}
msg_err ("loaded json is not an array");
return;
}
-
+
new_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
-
+
remove_dynamic_rules (jb->cfg->cache);
if (regexp_module_ctx->dynamic_pool != NULL) {
rspamd_mempool_delete (regexp_module_ctx->dynamic_pool);
msg_err ("factor is not a number or not exists, but is required");
continue;
}
- score = json_number_value (cur_nm);
+ score = json_number_value (cur_nm);
/* Symbol param */
cur_nm = json_object_get (cur_elt, "symbol");
if (cur_nm == NULL || !json_is_string (cur_nm)) {
msg_err ("symbol is not a string or not exists, but is required");
continue;
}
- cur_symbol = rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
+ cur_symbol =
+ rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
/* Enabled flag */
cur_nm = json_object_get (cur_elt, "enabled");
if (cur_nm != NULL && json_is_boolean (cur_nm)) {
/* Rule */
cur_nm = json_object_get (cur_elt, "rule");
if (cur_nm != NULL && json_is_string (cur_nm)) {
- cur_rule = rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
+ cur_rule =
+ rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
}
/* Networks array */
cur_nm = json_object_get (cur_elt, "networks");
for (j = 0; j < json_array_size (cur_nm); j++) {
it_val = json_array_get (cur_nm, i);
if (it_val && json_is_string (it_val)) {
- cur_nitem = rspamd_mempool_alloc (new_pool, sizeof (struct dynamic_map_item));
- if (parse_regexp_ipmask (json_string_value (it_val), cur_nitem)) {
+ cur_nitem =
+ rspamd_mempool_alloc (new_pool,
+ sizeof (struct dynamic_map_item));
+ if (parse_regexp_ipmask (json_string_value (it_val),
+ cur_nitem)) {
cur_networks = g_list_prepend (cur_networks, cur_nitem);
}
}
}
if (cur_rule) {
/* Dynamic rule has rule option */
- cur_item = rspamd_mempool_alloc0 (new_pool, sizeof (struct regexp_module_item));
+ cur_item =
+ rspamd_mempool_alloc0 (new_pool,
+ sizeof (struct regexp_module_item));
cur_item->symbol = cur_symbol;
- if (read_regexp_expression (new_pool, cur_item, cur_symbol, cur_rule, jb->cfg->raw_mode)) {
- register_dynamic_symbol (new_pool, &jb->cfg->cache, cur_symbol, score, process_regexp_item, cur_item, cur_networks);
+ if (read_regexp_expression (new_pool, cur_item, cur_symbol,
+ cur_rule, jb->cfg->raw_mode)) {
+ register_dynamic_symbol (new_pool,
+ &jb->cfg->cache,
+ cur_symbol,
+ score,
+ process_regexp_item,
+ cur_item,
+ cur_networks);
}
else {
msg_warn ("cannot parse dynamic rule");
}
else {
/* Just rule that is allways true (for whitelisting for example) */
- register_dynamic_symbol (new_pool, &jb->cfg->cache, cur_symbol, score, regexp_dynamic_insert_result, cur_symbol, cur_networks);
+ register_dynamic_symbol (new_pool,
+ &jb->cfg->cache,
+ cur_symbol,
+ score,
+ regexp_dynamic_insert_result,
+ cur_symbol,
+ cur_networks);
}
if (cur_networks) {
g_list_free (cur_networks);
{
regexp_module_ctx = g_malloc (sizeof (struct regexp_ctx));
- regexp_module_ctx->regexp_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ regexp_module_ctx->regexp_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
regexp_module_ctx->dynamic_pool = NULL;
- regexp_module_ctx->autolearn_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+ regexp_module_ctx->autolearn_symbols = g_hash_table_new (rspamd_str_hash,
+ rspamd_str_equal);
regexp_module_ctx->workers = NULL;
*ctx = (struct module_ctx *)regexp_module_ctx;
- register_expression_function ("regexp_match_number", rspamd_regexp_match_number, NULL);
- register_expression_function ("regexp_occurs_number", rspamd_regexp_occurs_number, NULL);
- register_expression_function ("raw_header_exists", rspamd_raw_header_exists, NULL);
- register_expression_function ("check_smtp_data", rspamd_check_smtp_data, NULL);
- register_expression_function ("content_type_is_type", rspamd_content_type_is_type, NULL);
- register_expression_function ("content_type_is_subtype", rspamd_content_type_is_subtype, NULL);
- register_expression_function ("content_type_has_param", rspamd_content_type_has_param, NULL);
- register_expression_function ("content_type_compare_param", rspamd_content_type_compare_param, NULL);
- register_expression_function ("has_content_part", rspamd_has_content_part, NULL);
- register_expression_function ("has_content_part_len", rspamd_has_content_part_len, NULL);
+ register_expression_function ("regexp_match_number",
+ rspamd_regexp_match_number,
+ NULL);
+ register_expression_function ("regexp_occurs_number",
+ rspamd_regexp_occurs_number,
+ NULL);
+ register_expression_function ("raw_header_exists",
+ rspamd_raw_header_exists,
+ NULL);
+ register_expression_function ("check_smtp_data",
+ rspamd_check_smtp_data,
+ NULL);
+ register_expression_function ("content_type_is_type",
+ rspamd_content_type_is_type,
+ NULL);
+ register_expression_function ("content_type_is_subtype",
+ rspamd_content_type_is_subtype,
+ NULL);
+ register_expression_function ("content_type_has_param",
+ rspamd_content_type_has_param,
+ NULL);
+ register_expression_function ("content_type_compare_param",
+ rspamd_content_type_compare_param,
+ NULL);
+ register_expression_function ("has_content_part",
+ rspamd_has_content_part,
+ NULL);
+ register_expression_function ("has_content_part_len",
+ rspamd_has_content_part_len,
+ NULL);
(void)luaopen_regexp (cfg->lua_state);
}
-/*
+/*
* Parse string in format:
* SYMBOL:statfile:weight
*/
void
-parse_autolearn_param (const gchar *param, const gchar *value, struct rspamd_config *cfg)
+parse_autolearn_param (const gchar *param,
+ const gchar *value,
+ struct rspamd_config *cfg)
{
- struct autolearn_data *d;
- gchar *p;
+ struct autolearn_data *d;
+ gchar *p;
p = rspamd_mempool_strdup (regexp_module_ctx->regexp_pool, value);
- d = rspamd_mempool_alloc (regexp_module_ctx->regexp_pool, sizeof (struct autolearn_data));
+ d =
+ rspamd_mempool_alloc (regexp_module_ctx->regexp_pool,
+ sizeof (struct autolearn_data));
d->symbol = strsep (&p, ":");
if (d->symbol) {
if (d->statfile_name) {
if (p != NULL && *p != '\0') {
d->weight = strtod (p, NULL);
- g_hash_table_insert (regexp_module_ctx->autolearn_symbols, d->symbol, d);
+ g_hash_table_insert (regexp_module_ctx->autolearn_symbols,
+ d->symbol,
+ d);
}
}
else {
gint
regexp_module_config (struct rspamd_config *cfg)
{
- struct regexp_module_item *cur_item;
- const ucl_object_t *sec, *value;
- ucl_object_iter_t it = NULL;
- gint res = TRUE;
- struct regexp_json_buf *jb, **pjb;
+ struct regexp_module_item *cur_item;
+ const ucl_object_t *sec, *value;
+ ucl_object_iter_t it = NULL;
+ gint res = TRUE;
+ struct regexp_json_buf *jb, **pjb;
sec = ucl_object_find_key (cfg->rcl_obj, "regexp");
regexp_module_ctx->workers = NULL;
while ((value = ucl_iterate_object (sec, &it, true)) != NULL) {
- if (g_ascii_strncasecmp (ucl_object_key (value), "autolearn", sizeof ("autolearn") - 1) == 0) {
- parse_autolearn_param (ucl_object_key (value), ucl_obj_tostring (value), cfg);
+ if (g_ascii_strncasecmp (ucl_object_key (value), "autolearn",
+ sizeof ("autolearn") - 1) == 0) {
+ parse_autolearn_param (ucl_object_key (value),
+ ucl_obj_tostring (value), cfg);
}
- else if (g_ascii_strncasecmp (ucl_object_key (value), "dynamic_rules", sizeof ("dynamic_rules") - 1) == 0) {
+ else if (g_ascii_strncasecmp (ucl_object_key (value), "dynamic_rules",
+ sizeof ("dynamic_rules") - 1) == 0) {
jb = g_malloc (sizeof (struct regexp_json_buf));
pjb = g_malloc (sizeof (struct regexp_json_buf *));
jb->buf = NULL;
jb->cfg = cfg;
*pjb = jb;
if (!add_map (cfg, ucl_obj_tostring (value),
- "Dynamic regexp rules", json_regexp_read_cb, json_regexp_fin_cb,
- (void **)pjb)) {
+ "Dynamic regexp rules", json_regexp_read_cb, json_regexp_fin_cb,
+ (void **)pjb)) {
msg_err ("cannot add map %s", ucl_obj_tostring (value));
}
}
- else if (g_ascii_strncasecmp (ucl_object_key (value), "max_size", sizeof ("max_size") - 1) == 0) {
+ else if (g_ascii_strncasecmp (ucl_object_key (value), "max_size",
+ sizeof ("max_size") - 1) == 0) {
regexp_module_ctx->max_size = ucl_obj_toint (value);
}
- else if (g_ascii_strncasecmp (ucl_object_key (value), "max_threads", sizeof ("max_threads") - 1) == 0) {
+ else if (g_ascii_strncasecmp (ucl_object_key (value), "max_threads",
+ sizeof ("max_threads") - 1) == 0) {
regexp_module_ctx->max_threads = ucl_obj_toint (value);
}
else if (value->type == UCL_STRING) {
- cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool, sizeof (struct regexp_module_item));
+ cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
+ sizeof (struct regexp_module_item));
cur_item->symbol = ucl_object_key (value);
- if (!read_regexp_expression (regexp_module_ctx->regexp_pool, cur_item, ucl_object_key (value),
- ucl_obj_tostring (value), cfg->raw_mode)) {
+ if (!read_regexp_expression (regexp_module_ctx->regexp_pool,
+ cur_item, ucl_object_key (value),
+ ucl_obj_tostring (value), cfg->raw_mode)) {
res = FALSE;
}
- register_symbol (&cfg->cache, cur_item->symbol, 1, process_regexp_item, cur_item);
+ register_symbol (&cfg->cache,
+ cur_item->symbol,
+ 1,
+ process_regexp_item,
+ cur_item);
}
else if (value->type == UCL_USERDATA) {
- cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool, sizeof (struct regexp_module_item));
+ cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
+ sizeof (struct regexp_module_item));
cur_item->symbol = ucl_object_key (value);
cur_item->lua_function = value->value.ud;
- register_symbol (&cfg->cache, cur_item->symbol, 1, process_regexp_item, cur_item);
+ register_symbol (&cfg->cache,
+ cur_item->symbol,
+ 1,
+ process_regexp_item,
+ cur_item);
}
else {
- msg_warn ("unknown type of attribute %s for regexp module", ucl_object_key (value));
+ msg_warn ("unknown type of attribute %s for regexp module",
+ ucl_object_key (value));
}
}
regexp_module_reconfig (struct rspamd_config *cfg)
{
rspamd_mempool_delete (regexp_module_ctx->regexp_pool);
- regexp_module_ctx->regexp_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ regexp_module_ctx->regexp_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
return regexp_module_config (cfg);
}
struct url_regexp_param {
- struct rspamd_task *task;
- GRegex *regexp;
- struct rspamd_regexp *re;
- gboolean found;
+ struct rspamd_task *task;
+ GRegex *regexp;
+ struct rspamd_regexp *re;
+ gboolean found;
};
-static gboolean
+static gboolean
tree_url_callback (gpointer key, gpointer value, void *data)
{
- struct url_regexp_param *param = data;
- struct uri *url = value;
- GError *err = NULL;
+ struct url_regexp_param *param = data;
+ struct uri *url = value;
+ GError *err = NULL;
- if (g_regex_match_full (param->regexp, struri (url), -1, 0, 0, NULL, &err) == TRUE) {
+ if (g_regex_match_full (param->regexp, struri (url), -1, 0, 0, NULL,
+ &err) == TRUE) {
if (G_UNLIKELY (param->re->is_test)) {
- msg_info ("process test regexp %s for url %s returned TRUE", struri (url));
+ msg_info ("process test regexp %s for url %s returned TRUE",
+ struri (url));
}
task_cache_add (param->task, param->re, 1);
param->found = TRUE;
return TRUE;
}
else if (G_UNLIKELY (param->re->is_test)) {
- msg_info ("process test regexp %s for url %s returned FALSE", struri (url));
+ msg_info ("process test regexp %s for url %s returned FALSE",
+ struri (url));
}
if (err != NULL) {
- msg_info ("error occured while processing regexp \"%s\": %s", param->re->regexp_text, err->message);
+ msg_info ("error occured while processing regexp \"%s\": %s",
+ param->re->regexp_text,
+ err->message);
}
return FALSE;
}
-static gsize
-process_regexp (struct rspamd_regexp *re, struct rspamd_task *task, const gchar *additional,
- gint limit, int_compare_func f)
+static gsize
+process_regexp (struct rspamd_regexp *re,
+ struct rspamd_task *task,
+ const gchar *additional,
+ gint limit,
+ int_compare_func f)
{
- guint8 *ct;
- gsize clen;
- gint r, passed = 0, start, end, old;
- gboolean matched = FALSE;
-
- GList *cur, *headerlist;
- GRegex *regexp;
- GMatchInfo *info;
- GError *err = NULL;
- struct url_regexp_param callback_param = {
+ guint8 *ct;
+ gsize clen;
+ gint r, passed = 0, start, end, old;
+ gboolean matched = FALSE;
+
+ GList *cur, *headerlist;
+ GRegex *regexp;
+ GMatchInfo *info;
+ GError *err = NULL;
+ struct url_regexp_param callback_param = {
.task = task,
.re = re,
.found = FALSE
};
- struct mime_text_part *part;
- struct raw_header *rh;
+ struct mime_text_part *part;
+ struct raw_header *rh;
if (re == NULL) {
msg_info ("invalid regexp passed");
callback_param.regexp = re->regexp;
if ((r = task_cache_check (task, re)) != -1) {
- debug_task ("regexp /%s/ is found in cache, result: %d", re->regexp_text, r);
+ debug_task ("regexp /%s/ is found in cache, result: %d",
+ re->regexp_text,
+ r);
return r == 1;
}
-
+
if (additional != NULL) {
/* We have additional parameter defined, so ignore type of regexp expression and use it for parsing */
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s with test %s", re->regexp_text, additional);
+ msg_info ("process test regexp %s with test %s",
+ re->regexp_text,
+ additional);
}
- if (g_regex_match_full (re->regexp, additional, strlen (additional), 0, 0, NULL, NULL) == TRUE) {
+ if (g_regex_match_full (re->regexp, additional, strlen (additional), 0,
+ 0, NULL, NULL) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
msg_info ("result of regexp %s is true", re->regexp_text);
}
switch (re->type) {
case REGEXP_NONE:
- msg_warn ("bad error detected: %s has invalid regexp type", re->regexp_text);
+ msg_warn ("bad error detected: %s has invalid regexp type",
+ re->regexp_text);
return 0;
case REGEXP_HEADER:
/* Check header's name */
if (re->header == NULL) {
- msg_info ("header regexp without header name: '%s'", re->regexp_text);
+ msg_info ("header regexp without header name: '%s'",
+ re->regexp_text);
task_cache_add (task, re, 0);
return 0;
}
- debug_task ("checking header regexp: %s = %s", re->header, re->regexp_text);
+ debug_task ("checking header regexp: %s = %s",
+ re->header,
+ re->regexp_text);
/* Get list of specified headers */
- headerlist = message_get_header (task->task_pool, task->message, re->header, re->is_strong);
+ headerlist = message_get_header (task->task_pool,
+ task->message,
+ re->header,
+ re->is_strong);
if (headerlist == NULL) {
/* Header is not found */
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for header %s returned FALSE: no header found", re->regexp_text, re->header);
+ msg_info (
+ "process test regexp %s for header %s returned FALSE: no header found",
+ re->regexp_text,
+ re->header);
}
task_cache_add (task, re, 0);
return 0;
}
else {
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, headerlist);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_list_free, headerlist);
/* Check whether we have regexp for it */
if (re->regexp == NULL) {
- debug_task ("regexp contains only header and it is found %s", re->header);
+ debug_task ("regexp contains only header and it is found %s",
+ re->header);
task_cache_add (task, re, 1);
return 1;
}
/* Iterate throught headers */
cur = headerlist;
while (cur) {
- debug_task ("found header \"%s\" with value \"%s\"", re->header, (const gchar *)cur->data);
+ debug_task ("found header \"%s\" with value \"%s\"",
+ re->header,
+ (const gchar *)cur->data);
/* Try to match regexp */
if (!re->is_raw) {
/* Validate input */
continue;
}
}
- if (cur->data && g_regex_match_full (re->regexp, cur->data, -1, 0, 0, NULL, &err) == TRUE) {
+ if (cur->data &&
+ g_regex_match_full (re->regexp, cur->data, -1, 0, 0, NULL,
+ &err) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for header %s with value '%s' returned TRUE", re->regexp_text, re->header, (const gchar *)cur->data);
+ msg_info (
+ "process test regexp %s for header %s with value '%s' returned TRUE",
+ re->regexp_text,
+ re->header,
+ (const gchar *)cur->data);
}
if (f != NULL && limit > 1) {
/* If we have limit count, increase passed count and compare with limit */
}
}
else if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for header %s with value '%s' returned FALSE", re->regexp_text, re->header, (const gchar *)cur->data);
+ msg_info (
+ "process test regexp %s for header %s with value '%s' returned FALSE",
+ re->regexp_text,
+ re->header,
+ (const gchar *)cur->data);
}
if (err != NULL) {
- msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
+ msg_info (
+ "error occured while processing regexp \"%s\": %s",
+ re->regexp_text,
+ err->message);
}
cur = g_list_next (cur);
}
continue;
}
/* Skip too large parts */
- if (regexp_module_ctx->max_size != 0 && part->content->len > regexp_module_ctx->max_size) {
- msg_info ("<%s> skip part of size %Hud", task->message_id, part->content->len);
+ if (regexp_module_ctx->max_size != 0 && part->content->len >
+ regexp_module_ctx->max_size) {
+ msg_info ("<%s> skip part of size %Hud",
+ task->message_id,
+ part->content->len);
cur = g_list_next (cur);
continue;
}
/* If we have limit, apply regexp so much times as we can */
if (f != NULL && limit > 1) {
end = 0;
- while ((matched = g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0, 0, &info, &err)) == TRUE) {
+ while ((matched =
+ g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0,
+ 0, &info, &err)) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for mime part of length %d returned TRUE",
- re->regexp_text,
- (gint)clen,
- end);
+ msg_info (
+ "process test regexp %s for mime part of length %d returned TRUE",
+ re->regexp_text,
+ (gint)clen,
+ end);
}
if (f (++passed, limit)) {
task_cache_add (task, re, 1);
else {
/* Match not found, skip further cycles */
old = end;
- if (!g_match_info_fetch_pos (info, 0, &start, &end) || end <= 0) {
+ if (!g_match_info_fetch_pos (info, 0, &start,
+ &end) || end <= 0) {
break;
}
end += old;
g_match_info_free (info);
}
else {
- if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL, &err) == TRUE) {
+ if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL,
+ &err) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for mime part of length %d returned TRUE", re->regexp_text,
- (gint)clen);
+ msg_info (
+ "process test regexp %s for mime part of length %d returned TRUE",
+ re->regexp_text,
+ (gint)clen);
}
task_cache_add (task, re, 1);
return 1;
}
if (!matched && G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for mime part of length %d returned FALSE", re->regexp_text,
- (gint)clen);
+ msg_info (
+ "process test regexp %s for mime part of length %d returned FALSE",
+ re->regexp_text,
+ (gint)clen);
}
if (err != NULL) {
- msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
+ msg_info ("error occured while processing regexp \"%s\": %s",
+ re->regexp_text,
+ err->message);
}
cur = g_list_next (cur);
}
ct = task->msg->str;
clen = task->msg->len;
- if (regexp_module_ctx->max_size != 0 && clen > regexp_module_ctx->max_size) {
+ if (regexp_module_ctx->max_size != 0 && clen >
+ regexp_module_ctx->max_size) {
msg_info ("<%s> skip message of size %Hz", task->message_id, clen);
return 0;
}
/* If we have limit, apply regexp so much times as we can */
if (f != NULL && limit > 1) {
end = 0;
- while ((matched = g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0, 0, &info, &err)) == TRUE) {
+ while ((matched =
+ g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0, 0,
+ &info, &err)) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for mime part of length %d returned TRUE", re->regexp_text,
- (gint)clen);
+ msg_info (
+ "process test regexp %s for mime part of length %d returned TRUE",
+ re->regexp_text,
+ (gint)clen);
}
if (f (++passed, limit)) {
task_cache_add (task, re, 1);
else {
/* Match not found, skip further cycles */
old = end;
- if (!g_match_info_fetch_pos (info, 0, &start, &end) || end <= 0) {
+ if (!g_match_info_fetch_pos (info, 0, &start,
+ &end) || end <= 0) {
break;
}
old += end;
g_match_info_free (info);
}
else {
- if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL, &err) == TRUE) {
+ if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL,
+ &err) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for message part of length %d returned TRUE", re->regexp_text,
- (gint)clen);
+ msg_info (
+ "process test regexp %s for message part of length %d returned TRUE",
+ re->regexp_text,
+ (gint)clen);
}
task_cache_add (task, re, 1);
return 1;
}
if (!matched && G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for message part of length %d returned FALSE", re->regexp_text,
- (gint)clen);
+ msg_info (
+ "process test regexp %s for message part of length %d returned FALSE",
+ re->regexp_text,
+ (gint)clen);
}
if (err != NULL) {
- msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
+ msg_info ("error occured while processing regexp \"%s\": %s",
+ re->regexp_text,
+ err->message);
}
task_cache_add (task, re, 0);
return 0;
}
return 0;
case REGEXP_RAW_HEADER:
- debug_task ("checking for raw header: %s with regexp: %s", re->header, re->regexp_text);
+ debug_task ("checking for raw header: %s with regexp: %s",
+ re->header,
+ re->regexp_text);
/* Check header's name */
if (re->header == NULL) {
- msg_info ("header regexp without header name: '%s'", re->regexp_text);
+ msg_info ("header regexp without header name: '%s'",
+ re->regexp_text);
task_cache_add (task, re, 0);
return 0;
}
- debug_task ("checking header regexp: %s = %s", re->header, re->regexp_text);
+ debug_task ("checking header regexp: %s = %s",
+ re->header,
+ re->regexp_text);
/* Get list of specified headers */
headerlist = message_get_raw_header (task, re->header, re->is_strong);
if (headerlist == NULL) {
/* Header is not found */
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for header %s returned FALSE: no header found", re->regexp_text, re->header);
+ msg_info (
+ "process test regexp %s for header %s returned FALSE: no header found",
+ re->regexp_text,
+ re->header);
}
task_cache_add (task, re, 0);
return 0;
else {
/* Check whether we have regexp for it */
if (re->regexp == NULL) {
- debug_task ("regexp contains only header and it is found %s", re->header);
+ debug_task ("regexp contains only header and it is found %s",
+ re->header);
task_cache_add (task, re, 1);
return 1;
}
/* Iterate throught headers */
cur = headerlist;
while (cur) {
- debug_task ("found header \"%s\" with value \"%s\"", re->header, (const gchar *)cur->data);
+ debug_task ("found header \"%s\" with value \"%s\"",
+ re->header,
+ (const gchar *)cur->data);
rh = cur->data;
/* Try to match regexp */
if (!re->is_raw) {
continue;
}
}
- if (rh->value && g_regex_match_full (re->regexp, rh->value, -1, 0, 0, NULL, &err) == TRUE) {
+ if (rh->value &&
+ g_regex_match_full (re->regexp, rh->value, -1, 0, 0, NULL,
+ &err) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for header %s with value '%s' returned TRUE", re->regexp_text, re->header, (const gchar *)cur->data);
+ msg_info (
+ "process test regexp %s for header %s with value '%s' returned TRUE",
+ re->regexp_text,
+ re->header,
+ (const gchar *)cur->data);
}
if (f != NULL && limit > 1) {
/* If we have limit count, increase passed count and compare with limit */
}
}
else if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for header %s with value '%s' returned FALSE", re->regexp_text, re->header, (const gchar *)cur->data);
+ msg_info (
+ "process test regexp %s for header %s with value '%s' returned FALSE",
+ re->regexp_text,
+ re->header,
+ (const gchar *)cur->data);
}
if (err != NULL) {
- msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
+ msg_info (
+ "error occured while processing regexp \"%s\": %s",
+ re->regexp_text,
+ err->message);
}
cur = g_list_next (cur);
}
}
static gboolean
-maybe_call_lua_function (const gchar *name, struct rspamd_task *task, lua_State *L)
+maybe_call_lua_function (const gchar *name,
+ struct rspamd_task *task,
+ lua_State *L)
{
- struct rspamd_task **ptask;
- gboolean res;
+ struct rspamd_task **ptask;
+ gboolean res;
lua_getglobal (L, name);
if (lua_isfunction (L, -1)) {
*ptask = task;
/* Call function */
if (lua_pcall (L, 1, 1, 0) != 0) {
- msg_info ("call to %s failed: %s", (gchar *)name, lua_tostring (L, -1));
+ msg_info ("call to %s failed: %s", (gchar *)name,
+ lua_tostring (L, -1));
return FALSE;
}
res = lua_toboolean (L, -1);
return FALSE;
}
-static gboolean
+static gboolean
optimize_regexp_expression (struct expression **e, GQueue * stack, gboolean res)
{
- struct expression *it = (*e)->next;
- gboolean ret = FALSE, is_nearest = TRUE;
- gint skip_level = 0;
+ struct expression *it = (*e)->next;
+ gboolean ret = FALSE, is_nearest = TRUE;
+ gint skip_level = 0;
/* Skip nearest logical operators from optimization */
if (!it || (it->type == EXPR_OPERATION && it->content.operation != '!')) {
return ret;
}
-static gboolean
-process_regexp_expression (struct expression *expr, const gchar *symbol, struct rspamd_task *task,
- const gchar *additional, struct lua_locked_state *nL)
+static gboolean
+process_regexp_expression (struct expression *expr,
+ const gchar *symbol,
+ struct rspamd_task *task,
+ const gchar *additional,
+ struct lua_locked_state *nL)
{
- GQueue *stack;
- gsize cur, op1, op2;
- struct expression *it = expr;
- struct rspamd_regexp *re;
- gboolean try_optimize = TRUE;
+ GQueue *stack;
+ gsize cur, op1, op2;
+ struct expression *it = expr;
+ struct rspamd_regexp *re;
+ gboolean try_optimize = TRUE;
stack = g_queue_new ();
while (it) {
if (it->type == EXPR_REGEXP_PARSED) {
/* Find corresponding symbol */
- cur = process_regexp ((struct rspamd_regexp *)it->content.operand, task, additional, 0, NULL);
+ cur = process_regexp ((struct rspamd_regexp *)it->content.operand,
+ task,
+ additional,
+ 0,
+ NULL);
debug_task ("regexp %s found", cur ? "is" : "is not");
if (try_optimize) {
try_optimize = optimize_regexp_expression (&it, stack, cur);
else if (it->type == EXPR_FUNCTION) {
if (nL) {
rspamd_mutex_lock (nL->m);
- cur = (gsize) call_expression_function ((struct expression_function *)it->content.operand, task, nL->L);
+ cur =
+ (gsize) call_expression_function ((struct
+ expression_function
+ *)it->content.operand, task, nL->L);
rspamd_mutex_unlock (nL->m);
}
else {
- cur = (gsize) call_expression_function ((struct expression_function *)it->content.operand, task, task->cfg->lua_state);
- }
- debug_task ("function %s returned %s", ((struct expression_function *)it->content.operand)->name, cur ? "true" : "false");
+ cur =
+ (gsize) call_expression_function ((struct
+ expression_function
+ *)it->content.operand, task, task->cfg->lua_state);
+ }
+ debug_task ("function %s returned %s",
+ ((struct expression_function *)it->content.operand)->name,
+ cur ? "true" : "false");
if (try_optimize) {
try_optimize = optimize_regexp_expression (&it, stack, cur);
}
/* This may be lua function, try to call it */
if (nL) {
rspamd_mutex_lock (nL->m);
- cur = maybe_call_lua_function ((const gchar*)it->content.operand, task, nL->L);
+ cur = maybe_call_lua_function (
+ (const gchar *)it->content.operand,
+ task,
+ nL->L);
rspamd_mutex_unlock (nL->m);
}
else {
- cur = maybe_call_lua_function ((const gchar*)it->content.operand, task, task->cfg->lua_state);
- }
- debug_task ("function %s returned %s", (const gchar *)it->content.operand, cur ? "true" : "false");
+ cur = maybe_call_lua_function (
+ (const gchar *)it->content.operand,
+ task,
+ task->cfg->lua_state);
+ }
+ debug_task ("function %s returned %s",
+ (const gchar *)it->content.operand,
+ cur ? "true" : "false");
if (try_optimize) {
try_optimize = optimize_regexp_expression (&it, stack, cur);
}
it = it->next;
continue;
}
- re = parse_regexp (task->cfg->cfg_pool, it->content.operand, task->cfg->raw_mode);
+ re = parse_regexp (task->cfg->cfg_pool,
+ it->content.operand,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot parse regexp, skip expression");
g_queue_free (stack);
else if (it->type == EXPR_OPERATION) {
if (g_queue_is_empty (stack)) {
/* Queue has no operands for operation, exiting */
- msg_warn ("regexp expression seems to be invalid: empty stack while reading operation");
+ msg_warn (
+ "regexp expression seems to be invalid: empty stack while reading operation");
g_queue_free (stack);
return FALSE;
}
case '&':
op1 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
op2 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
- try_optimize = optimize_regexp_expression (&it, stack, op1 && op2);
+ try_optimize = optimize_regexp_expression (&it,
+ stack,
+ op1 && op2);
break;
case '|':
op1 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
op2 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
- try_optimize = optimize_regexp_expression (&it, stack, op1 || op2);
+ try_optimize = optimize_regexp_expression (&it,
+ stack,
+ op1 || op2);
break;
default:
it = it->next;
}
}
else {
- msg_warn ("regexp expression seems to be invalid: empty stack at the end of expression, symbol %s", symbol);
+ msg_warn (
+ "regexp expression seems to be invalid: empty stack at the end of expression, symbol %s",
+ symbol);
}
g_queue_free (stack);
static void
process_regexp_item_threaded (gpointer data, gpointer user_data)
{
- struct regexp_threaded_ud *ud = data;
- struct lua_locked_state *nL = user_data;
+ struct regexp_threaded_ud *ud = data;
+ struct lua_locked_state *nL = user_data;
/* Process expression */
- if (process_regexp_expression (ud->item->expr, ud->item->symbol, ud->task, NULL, nL)) {
+ if (process_regexp_expression (ud->item->expr, ud->item->symbol, ud->task,
+ NULL, nL)) {
g_mutex_lock (workers_mtx);
insert_result (ud->task, ud->item->symbol, 1, NULL);
g_mutex_unlock (workers_mtx);
static void
process_regexp_item (struct rspamd_task *task, void *user_data)
{
- struct regexp_module_item *item = user_data;
- gboolean res = FALSE;
- struct regexp_threaded_ud *thr_ud;
- GError *err = NULL;
- struct lua_locked_state *nL;
+ struct regexp_module_item *item = user_data;
+ gboolean res = FALSE;
+ struct regexp_threaded_ud *thr_ud;
+ GError *err = NULL;
+ struct lua_locked_state *nL;
if (!item->lua_function && regexp_module_ctx->max_threads > 1) {
if (regexp_module_ctx->workers == NULL) {
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
# if GLIB_MINOR_VERSION > 20
- if (! g_thread_get_initialized ()) {
+ if (!g_thread_get_initialized ()) {
g_thread_init (NULL);
}
# else
# endif
workers_mtx = g_mutex_new ();
#else
- workers_mtx = rspamd_mempool_alloc (regexp_module_ctx->regexp_pool, sizeof (GMutex));
+ workers_mtx = rspamd_mempool_alloc (regexp_module_ctx->regexp_pool,
+ sizeof (GMutex));
g_mutex_init (workers_mtx);
#endif
nL = init_lua_locked (task->cfg);
luaopen_regexp (nL->L);
- regexp_module_ctx->workers = g_thread_pool_new (process_regexp_item_threaded,
- nL, regexp_module_ctx->max_threads, TRUE, &err);
+ regexp_module_ctx->workers = g_thread_pool_new (
+ process_regexp_item_threaded,
+ nL,
+ regexp_module_ctx->max_threads,
+ TRUE,
+ &err);
if (err != NULL) {
msg_err ("thread pool creation failed: %s", err->message);
regexp_module_ctx->max_threads = 0;
return;
}
}
- thr_ud = rspamd_mempool_alloc (task->task_pool, sizeof (struct regexp_threaded_ud));
+ thr_ud =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct regexp_threaded_ud));
thr_ud->item = item;
thr_ud->task = task;
register_async_thread (task->s);
g_thread_pool_push (regexp_module_ctx->workers, thr_ud, &err);
if (err != NULL) {
- msg_err ("error pushing task to the regexp thread pool: %s", err->message);
+ msg_err ("error pushing task to the regexp thread pool: %s",
+ err->message);
remove_async_thread (task->s);
}
}
/* Non-threaded version */
if (item->lua_function) {
/* Just call function */
- if (lua_call_expression_func (item->lua_function, task, NULL, &res) && res) {
+ if (lua_call_expression_func (item->lua_function, task, NULL,
+ &res) && res) {
insert_result (task, item->symbol, 1, NULL);
}
}
else {
/* Process expression */
- if (process_regexp_expression (item->expr, item->symbol, task, NULL, NULL)) {
+ if (process_regexp_expression (item->expr, item->symbol, task, NULL,
+ NULL)) {
insert_result (task, item->symbol, 1, NULL);
}
}
}
}
-static gboolean
-rspamd_regexp_match_number (struct rspamd_task *task, GList * args, void *unused)
+static gboolean
+rspamd_regexp_match_number (struct rspamd_task *task, GList * args,
+ void *unused)
{
- gint param_count, res = 0;
- struct expression_argument *arg;
- GList *cur;
+ gint param_count, res = 0;
+ struct expression_argument *arg;
+ GList *cur;
if (args == NULL) {
msg_warn ("no parameters to function");
}
}
else {
- if (process_regexp_expression (cur->data, "regexp_match_number", task, NULL, NULL)) {
+ if (process_regexp_expression (cur->data, "regexp_match_number",
+ task, NULL, NULL)) {
res++;
}
if (res >= param_count) {
return res >= param_count;
}
-static gboolean
-rspamd_regexp_occurs_number (struct rspamd_task *task, GList * args, void *unused)
+static gboolean
+rspamd_regexp_occurs_number (struct rspamd_task *task,
+ GList * args,
+ void *unused)
{
- gint limit;
- struct expression_argument *arg;
- struct rspamd_regexp *re;
- gchar *param, *err_str, op;
- int_compare_func f = NULL;
+ gint limit;
+ struct expression_argument *arg;
+ struct rspamd_regexp *re;
+ gchar *param, *err_str, op;
+ int_compare_func f = NULL;
if (args == NULL || args->next == NULL) {
msg_warn ("wrong number of parameters to function, must be 2");
op = '=';
}
else {
- param ++;
+ param++;
}
switch (op) {
case '>':
if (*param == '=') {
f = op_more_equal;
- param ++;
+ param++;
}
else {
f = op_more;
case '<':
if (*param == '=') {
f = op_less_equal;
- param ++;
+ param++;
}
else {
f = op_less;
f = op_equal;
break;
default:
- msg_err ("wrong operation character: %c, assumed '=', '>', '<', '>=', '<=' or empty op", op);
+ msg_err (
+ "wrong operation character: %c, assumed '=', '>', '<', '>=', '<=' or empty op",
+ op);
return FALSE;
}
return process_regexp (re, task, NULL, limit, f);
}
-static gboolean
+static gboolean
rspamd_raw_header_exists (struct rspamd_task *task, GList * args, void *unused)
{
- struct expression_argument *arg;
+ struct expression_argument *arg;
if (args == NULL || task == NULL) {
return FALSE;
}
static gboolean
-match_smtp_data (struct rspamd_task *task, const gchar *re_text, const gchar *what)
+match_smtp_data (struct rspamd_task *task,
+ const gchar *re_text,
+ const gchar *what)
{
- struct rspamd_regexp *re;
- gint r;
+ struct rspamd_regexp *re;
+ gint r;
if (*re_text == '/') {
/* This is a regexp */
if ((re = re_cache_check (re_text, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, (gchar *)re_text, task->cfg->raw_mode);
+ re = parse_regexp (task->cfg->cfg_pool,
+ (gchar *)re_text,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
return FALSE;
return FALSE;
}
-static gboolean
+static gboolean
rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused)
{
- struct expression_argument *arg;
- GList *cur, *rcpt_list = NULL;
- gchar *type, *what = NULL;
+ struct expression_argument *arg;
+ GList *cur, *rcpt_list = NULL;
+ gchar *type, *what = NULL;
if (args == NULL) {
msg_warn ("no parameters to function");
else {
type = arg->data;
switch (*type) {
- case 'f':
- case 'F':
- if (g_ascii_strcasecmp (type, "from") == 0) {
- what = task->from;
- }
- else {
- msg_warn ("bad argument to function: %s", type);
- return FALSE;
- }
- break;
- case 'h':
- case 'H':
- if (g_ascii_strcasecmp (type, "helo") == 0) {
- what = task->helo;
- }
- else {
- msg_warn ("bad argument to function: %s", type);
- return FALSE;
- }
- break;
- case 'u':
- case 'U':
- if (g_ascii_strcasecmp (type, "user") == 0) {
- what = task->user;
- }
- else {
- msg_warn ("bad argument to function: %s", type);
- return FALSE;
- }
- break;
- case 's':
- case 'S':
- if (g_ascii_strcasecmp (type, "subject") == 0) {
- what = task->subject;
- }
- else {
- msg_warn ("bad argument to function: %s", type);
- return FALSE;
- }
- break;
- case 'r':
- case 'R':
- if (g_ascii_strcasecmp (type, "rcpt") == 0) {
- rcpt_list = task->rcpt;
- }
- else {
- msg_warn ("bad argument to function: %s", type);
- return FALSE;
- }
- break;
- default:
+ case 'f':
+ case 'F':
+ if (g_ascii_strcasecmp (type, "from") == 0) {
+ what = task->from;
+ }
+ else {
+ msg_warn ("bad argument to function: %s", type);
+ return FALSE;
+ }
+ break;
+ case 'h':
+ case 'H':
+ if (g_ascii_strcasecmp (type, "helo") == 0) {
+ what = task->helo;
+ }
+ else {
+ msg_warn ("bad argument to function: %s", type);
+ return FALSE;
+ }
+ break;
+ case 'u':
+ case 'U':
+ if (g_ascii_strcasecmp (type, "user") == 0) {
+ what = task->user;
+ }
+ else {
+ msg_warn ("bad argument to function: %s", type);
+ return FALSE;
+ }
+ break;
+ case 's':
+ case 'S':
+ if (g_ascii_strcasecmp (type, "subject") == 0) {
+ what = task->subject;
+ }
+ else {
msg_warn ("bad argument to function: %s", type);
return FALSE;
+ }
+ break;
+ case 'r':
+ case 'R':
+ if (g_ascii_strcasecmp (type, "rcpt") == 0) {
+ rcpt_list = task->rcpt;
+ }
+ else {
+ msg_warn ("bad argument to function: %s", type);
+ return FALSE;
+ }
+ break;
+ default:
+ msg_warn ("bad argument to function: %s", type);
+ return FALSE;
}
}
/* Not enough data so regexp would NOT be found anyway */
return FALSE;
}
-
+
/* We would process only one more argument, others are ignored */
cur = args->next;
if (cur) {
}
else if (arg != NULL) {
if (what != NULL) {
- if (process_regexp_expression (arg->data, "regexp_check_smtp_data", task, what, NULL)) {
+ if (process_regexp_expression (arg->data,
+ "regexp_check_smtp_data", task, what, NULL)) {
return TRUE;
}
}
else {
while (rcpt_list) {
- if (process_regexp_expression (arg->data, "regexp_check_smtp_data", task, rcpt_list->data, NULL)) {
+ if (process_regexp_expression (arg->data,
+ "regexp_check_smtp_data", task, rcpt_list->data,
+ NULL)) {
return TRUE;
}
rcpt_list = g_list_next (rcpt_list);
static gint
lua_regexp_match (lua_State *L)
{
- void *ud = luaL_checkudata (L, 1, "rspamd{task}");
- struct rspamd_task *task;
- const gchar *re_text;
- struct rspamd_regexp *re;
- gint r = 0;
+ void *ud = luaL_checkudata (L, 1, "rspamd{task}");
+ struct rspamd_task *task;
+ const gchar *re_text;
+ struct rspamd_regexp *re;
+ gint r = 0;
luaL_argcheck (L, ud != NULL, 1, "'task' expected");
task = ud ? *((struct rspamd_task **)ud) : NULL;
/* This is a regexp */
if (task != NULL) {
if ((re = re_cache_check (re_text, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, (gchar *)re_text, task->cfg->raw_mode);
+ re = parse_regexp (task->cfg->cfg_pool,
+ (gchar *)re_text,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
return FALSE;
}
static gboolean
-rspamd_content_type_compare_param (struct rspamd_task * task, GList * args, void *unused)
+rspamd_content_type_compare_param (struct rspamd_task * task,
+ GList * args,
+ void *unused)
{
- gchar *param_name, *param_pattern;
- const gchar *param_data;
- struct rspamd_regexp *re;
- struct expression_argument *arg, *arg1;
- GMimeObject *part;
- GMimeContentType *ct;
- gint r;
- gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
- struct mime_part *cur_part;
+ gchar *param_name, *param_pattern;
+ const gchar *param_data;
+ struct rspamd_regexp *re;
+ struct expression_argument *arg, *arg1;
+ GMimeObject *part;
+ GMimeContentType *ct;
+ gint r;
+ gboolean recursive = FALSE, result = FALSE;
+ GList *cur = NULL;
+ struct mime_part *cur_part;
if (args == NULL) {
msg_warn ("no parameters to function");
if (args->next) {
args = g_list_next (args);
arg1 = get_function_arg (args->data, task, TRUE);
- if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
+ if (g_ascii_strncasecmp (arg1->data, "true",
+ sizeof ("true") - 1) == 0) {
recursive = TRUE;
}
}
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;;) {
- if ((param_data = g_mime_content_type_get_parameter ((GMimeContentType *)ct, param_name)) == NULL) {
+ for (;; ) {
+ if ((param_data =
+ g_mime_content_type_get_parameter ((GMimeContentType *)ct,
+ param_name)) == NULL) {
result = FALSE;
}
else {
if (*param_pattern == '/') {
/* This is regexp, so compile and create g_regexp object */
- if ((re = re_cache_check (param_pattern, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, param_pattern, task->cfg->raw_mode);
+ if ((re =
+ re_cache_check (param_pattern,
+ task->cfg->cfg_pool)) == NULL) {
+ re = parse_regexp (task->cfg->cfg_pool,
+ param_pattern,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
return FALSE;
re_cache_add (param_pattern, re, task->cfg->cfg_pool);
}
if ((r = task_cache_check (task, re)) == -1) {
- if (g_regex_match (re->regexp, param_data, 0, NULL) == TRUE) {
+ if (g_regex_match (re->regexp, param_data, 0,
+ NULL) == TRUE) {
task_cache_add (task, re, 1);
return TRUE;
}
}
}
/* Get next part */
- if (! recursive) {
+ if (!recursive) {
return result;
}
else if (cur != NULL) {
}
static gboolean
-rspamd_content_type_has_param (struct rspamd_task * task, GList * args, void *unused)
+rspamd_content_type_has_param (struct rspamd_task * task,
+ GList * args,
+ void *unused)
{
- gchar *param_name;
- const gchar *param_data;
- struct expression_argument *arg, *arg1;
- GMimeObject *part;
- GMimeContentType *ct;
- gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
- struct mime_part *cur_part;
+ gchar *param_name;
+ const gchar *param_data;
+ struct expression_argument *arg, *arg1;
+ GMimeObject *part;
+ GMimeContentType *ct;
+ gboolean recursive = FALSE, result = FALSE;
+ GList *cur = NULL;
+ struct mime_part *cur_part;
if (args == NULL) {
msg_warn ("no parameters to function");
if (args->next) {
args = g_list_next (args);
arg1 = get_function_arg (args->data, task, TRUE);
- if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
+ if (g_ascii_strncasecmp (arg1->data, "true",
+ sizeof ("true") - 1) == 0) {
recursive = TRUE;
}
}
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;;) {
- if ((param_data = g_mime_content_type_get_parameter ((GMimeContentType *)ct, param_name)) != NULL) {
+ for (;; ) {
+ if ((param_data =
+ g_mime_content_type_get_parameter ((GMimeContentType *)ct,
+ param_name)) != NULL) {
return TRUE;
}
/* Get next part */
- if (! recursive) {
+ if (!recursive) {
return result;
}
else if (cur != NULL) {
}
static gboolean
-rspamd_content_type_is_subtype (struct rspamd_task *task, GList * args, void *unused)
+rspamd_content_type_is_subtype (struct rspamd_task *task,
+ GList * args,
+ void *unused)
{
- gchar *param_pattern;
- struct rspamd_regexp *re;
- struct expression_argument *arg, *arg1;
- GMimeObject *part;
- GMimeContentType *ct;
- gint r;
- gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
- struct mime_part *cur_part;
+ gchar *param_pattern;
+ struct rspamd_regexp *re;
+ struct expression_argument *arg, *arg1;
+ GMimeObject *part;
+ GMimeContentType *ct;
+ gint r;
+ gboolean recursive = FALSE, result = FALSE;
+ GList *cur = NULL;
+ struct mime_part *cur_part;
if (args == NULL) {
msg_warn ("no parameters to function");
if (args->next) {
args = g_list_next (args);
arg1 = get_function_arg (args->data, task, TRUE);
- if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
+ if (g_ascii_strncasecmp (arg1->data, "true",
+ sizeof ("true") - 1) == 0) {
recursive = TRUE;
}
}
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;;) {
+ for (;; ) {
if (*param_pattern == '/') {
/* This is regexp, so compile and create g_regexp object */
- if ((re = re_cache_check (param_pattern, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, param_pattern, task->cfg->raw_mode);
+ if ((re =
+ re_cache_check (param_pattern,
+ task->cfg->cfg_pool)) == NULL) {
+ re = parse_regexp (task->cfg->cfg_pool,
+ param_pattern,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
return FALSE;
re_cache_add (param_pattern, re, task->cfg->cfg_pool);
}
if ((r = task_cache_check (task, re)) == -1) {
- if (g_regex_match (re->regexp, ct->subtype, 0, NULL) == TRUE) {
+ if (g_regex_match (re->regexp, ct->subtype, 0,
+ NULL) == TRUE) {
task_cache_add (task, re, 1);
return TRUE;
}
}
}
/* Get next part */
- if (! recursive) {
+ if (!recursive) {
return result;
}
else if (cur != NULL) {
}
static gboolean
-rspamd_content_type_is_type (struct rspamd_task * task, GList * args, void *unused)
+rspamd_content_type_is_type (struct rspamd_task * task,
+ GList * args,
+ void *unused)
{
- gchar *param_pattern;
- struct rspamd_regexp *re;
- struct expression_argument *arg, *arg1;
- GMimeObject *part;
- GMimeContentType *ct;
- gint r;
- gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
- struct mime_part *cur_part;
+ gchar *param_pattern;
+ struct rspamd_regexp *re;
+ struct expression_argument *arg, *arg1;
+ GMimeObject *part;
+ GMimeContentType *ct;
+ gint r;
+ gboolean recursive = FALSE, result = FALSE;
+ GList *cur = NULL;
+ struct mime_part *cur_part;
if (args == NULL) {
msg_warn ("no parameters to function");
if (args->next) {
args = g_list_next (args);
arg1 = get_function_arg (args->data, task, TRUE);
- if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
+ if (g_ascii_strncasecmp (arg1->data, "true",
+ sizeof ("true") - 1) == 0) {
recursive = TRUE;
}
}
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;;) {
+ for (;; ) {
if (*param_pattern == '/') {
/* This is regexp, so compile and create g_regexp object */
- if ((re = re_cache_check (param_pattern, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, param_pattern, task->cfg->raw_mode);
+ if ((re =
+ re_cache_check (param_pattern,
+ task->cfg->cfg_pool)) == NULL) {
+ re = parse_regexp (task->cfg->cfg_pool,
+ param_pattern,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
return FALSE;
}
}
/* Get next part */
- if (! recursive) {
+ if (!recursive) {
return result;
}
else if (cur != NULL) {
return FALSE;
}
-static gboolean
-compare_subtype (struct rspamd_task *task, GMimeContentType * ct, gchar *subtype)
+static gboolean
+compare_subtype (struct rspamd_task *task, GMimeContentType * ct,
+ gchar *subtype)
{
- struct rspamd_regexp *re;
- gint r;
+ struct rspamd_regexp *re;
+ gint r;
if (subtype == NULL || ct == NULL) {
msg_warn ("invalid parameters passed");
if (*subtype == '/') {
/* This is regexp, so compile and create g_regexp object */
if ((re = re_cache_check (subtype, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, subtype, task->cfg->raw_mode);
+ re =
+ parse_regexp (task->cfg->cfg_pool, subtype,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
return FALSE;
return FALSE;
}
-static gboolean
+static gboolean
compare_len (struct mime_part *part, guint min, guint max)
{
if (min == 0 && max == 0) {
}
static gboolean
-common_has_content_part (struct rspamd_task * task, gchar *param_type, gchar *param_subtype, gint min_len, gint max_len)
+common_has_content_part (struct rspamd_task * task,
+ gchar *param_type,
+ gchar *param_subtype,
+ gint min_len,
+ gint max_len)
{
- struct rspamd_regexp *re;
- struct mime_part *part;
- GList *cur;
- GMimeContentType *ct;
- gint r;
+ struct rspamd_regexp *re;
+ struct mime_part *part;
+ GList *cur;
+ GMimeContentType *ct;
+ gint r;
cur = g_list_first (task->parts);
while (cur) {
if (*param_type == '/') {
/* This is regexp, so compile and create g_regexp object */
- if ((re = re_cache_check (param_type, task->cfg->cfg_pool)) == NULL) {
- re = parse_regexp (task->cfg->cfg_pool, param_type, task->cfg->raw_mode);
+ if ((re =
+ re_cache_check (param_type, task->cfg->cfg_pool)) == NULL) {
+ re = parse_regexp (task->cfg->cfg_pool,
+ param_type,
+ task->cfg->raw_mode);
if (re == NULL) {
msg_warn ("cannot compile regexp for function");
cur = g_list_next (cur);
re_cache_add (param_type, re, task->cfg->cfg_pool);
}
if ((r = task_cache_check (task, re)) == -1) {
- if (ct->type && g_regex_match (re->regexp, ct->type, 0, NULL) == TRUE) {
+ if (ct->type &&
+ g_regex_match (re->regexp, ct->type, 0, NULL) == TRUE) {
if (param_subtype) {
if (compare_subtype (task, ct, param_subtype)) {
if (compare_len (part, min_len, max_len)) {
static gboolean
rspamd_has_content_part (struct rspamd_task * task, GList * args, void *unused)
{
- gchar *param_type = NULL, *param_subtype = NULL;
- struct expression_argument *arg;
+ gchar *param_type = NULL, *param_subtype = NULL;
+ struct expression_argument *arg;
if (args == NULL) {
msg_warn ("no parameters to function");
}
static gboolean
-rspamd_has_content_part_len (struct rspamd_task * task, GList * args, void *unused)
+rspamd_has_content_part_len (struct rspamd_task * task,
+ GList * args,
+ void *unused)
{
- gchar *param_type = NULL, *param_subtype = NULL;
- gint min = 0, max = 0;
- struct expression_argument *arg;
+ gchar *param_type = NULL, *param_subtype = NULL;
+ gint min = 0, max = 0;
+ struct expression_argument *arg;
if (args == NULL) {
msg_warn ("no parameters to function");
errno = 0;
min = strtoul (arg->data, NULL, 10);
if (errno != 0) {
- msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
+ msg_warn ("invalid numeric value '%s': %s",
+ (gchar *)arg->data,
+ strerror (errno));
return FALSE;
}
args = args->next;
arg = get_function_arg (args->data, task, TRUE);
max = strtoul (arg->data, NULL, 10);
if (errno != 0) {
- msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
+ msg_warn ("invalid numeric value '%s': %s",
+ (gchar *)arg->data,
+ strerror (errno));
return FALSE;
}
}
* - whitelist (map): map of whitelisted networks
*/
-#include "config.h"
-#include "main.h"
-#include "message.h"
#include "cfg_file.h"
+#include "config.h"
#include "expressions.h"
-#include "util.h"
+#include "hash.h"
+#include "main.h"
#include "map.h"
+#include "message.h"
#include "spf.h"
-#include "hash.h"
+#include "util.h"
#define DEFAULT_SYMBOL_FAIL "R_SPF_FAIL"
#define DEFAULT_SYMBOL_SOFTFAIL "R_SPF_SOFTFAIL"
#define DEFAULT_CACHE_MAXAGE 86400
struct spf_ctx {
- gint (*filter) (struct rspamd_task * task);
- const gchar *symbol_fail;
- const gchar *symbol_softfail;
- const gchar *symbol_allow;
-
- rspamd_mempool_t *spf_pool;
- radix_tree_t *whitelist_ip;
- rspamd_lru_hash_t *spf_hash;
+ gint (*filter) (struct rspamd_task * task);
+ const gchar *symbol_fail;
+ const gchar *symbol_softfail;
+ const gchar *symbol_allow;
+
+ rspamd_mempool_t *spf_pool;
+ radix_tree_t *whitelist_ip;
+ rspamd_lru_hash_t *spf_hash;
};
-static struct spf_ctx *spf_module_ctx = NULL;
+static struct spf_ctx *spf_module_ctx = NULL;
-static void spf_symbol_callback (struct rspamd_task *task, void *unused);
-static GList * spf_record_copy (GList *addrs);
-static void spf_record_destroy (gpointer list);
+static void spf_symbol_callback (struct rspamd_task *task, void *unused);
+static GList * spf_record_copy (GList *addrs);
+static void spf_record_destroy (gpointer list);
/* Initialization */
gint spf_module_init (struct rspamd_config *cfg, struct module_ctx **ctx);
{
spf_module_ctx = g_malloc (sizeof (struct spf_ctx));
- spf_module_ctx->spf_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ spf_module_ctx->spf_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
*ctx = (struct module_ctx *)spf_module_ctx;
gint
spf_module_config (struct rspamd_config *cfg)
{
- const ucl_object_t *value;
- gint res = TRUE;
- guint cache_size, cache_expire;
+ const ucl_object_t *value;
+ gint res = TRUE;
+ guint cache_size, cache_expire;
spf_module_ctx->whitelist_ip = radix_tree_create ();
-
- if ((value = rspamd_config_get_module_opt (cfg, "spf", "symbol_fail")) != NULL) {
+
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "spf", "symbol_fail")) != NULL) {
spf_module_ctx->symbol_fail = ucl_obj_tostring (value);
}
else {
spf_module_ctx->symbol_fail = DEFAULT_SYMBOL_FAIL;
}
- if ((value = rspamd_config_get_module_opt (cfg, "spf", "symbol_softfail")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "spf", "symbol_softfail")) != NULL) {
spf_module_ctx->symbol_softfail = ucl_obj_tostring (value);
}
else {
spf_module_ctx->symbol_softfail = DEFAULT_SYMBOL_SOFTFAIL;
}
- if ((value = rspamd_config_get_module_opt (cfg, "spf", "symbol_allow")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "spf", "symbol_allow")) != NULL) {
spf_module_ctx->symbol_allow = ucl_obj_tostring (value);
}
else {
spf_module_ctx->symbol_allow = DEFAULT_SYMBOL_ALLOW;
}
- if ((value = rspamd_config_get_module_opt (cfg, "spf", "spf_cache_size")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "spf", "spf_cache_size")) != NULL) {
cache_size = ucl_obj_toint (value);
}
else {
cache_size = DEFAULT_CACHE_SIZE;
}
- if ((value = rspamd_config_get_module_opt (cfg, "spf", "spf_cache_expire")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "spf",
+ "spf_cache_expire")) != NULL) {
cache_expire = ucl_obj_toint (value);
}
else {
cache_expire = DEFAULT_CACHE_MAXAGE;
}
- if ((value = rspamd_config_get_module_opt (cfg, "spf", "whitelist")) != NULL) {
- if (! add_map (cfg, ucl_obj_tostring (value),
- "SPF whitelist", read_radix_list, fin_radix_list,
- (void **)&spf_module_ctx->whitelist_ip)) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "spf", "whitelist")) != NULL) {
+ if (!add_map (cfg, ucl_obj_tostring (value),
+ "SPF whitelist", read_radix_list, fin_radix_list,
+ (void **)&spf_module_ctx->whitelist_ip)) {
msg_warn ("cannot load whitelist from %s", value);
}
}
- register_symbol (&cfg->cache, spf_module_ctx->symbol_fail, 1, spf_symbol_callback, NULL);
+ register_symbol (&cfg->cache,
+ spf_module_ctx->symbol_fail,
+ 1,
+ spf_symbol_callback,
+ NULL);
register_virtual_symbol (&cfg->cache, spf_module_ctx->symbol_softfail, 1);
- register_virtual_symbol (&cfg->cache, spf_module_ctx->symbol_allow, 1);
+ register_virtual_symbol (&cfg->cache, spf_module_ctx->symbol_allow, 1);
- spf_module_ctx->spf_hash = rspamd_lru_hash_new (rspamd_strcase_hash, rspamd_strcase_equal,
- cache_size, cache_expire, g_free, spf_record_destroy);
+ spf_module_ctx->spf_hash = rspamd_lru_hash_new (rspamd_strcase_hash,
+ rspamd_strcase_equal,
+ cache_size,
+ cache_expire,
+ g_free,
+ spf_record_destroy);
return res;
}
{
rspamd_mempool_delete (spf_module_ctx->spf_pool);
radix_tree_free (spf_module_ctx->whitelist_ip);
- spf_module_ctx->spf_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ spf_module_ctx->spf_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
return spf_module_config (cfg);
}
static gboolean
spf_check_element (struct spf_addr *addr, struct rspamd_task *task)
{
- gboolean res = FALSE;
- guint8 *s, *d, t;
- guint nbits, addrlen;
- struct in_addr in4s, in4d;
- struct in6_addr in6s, in6d;
+ gboolean res = FALSE;
+ guint8 *s, *d, t;
+ guint nbits, addrlen;
+ struct in_addr in4s, in4d;
+ struct in6_addr in6s, in6d;
/* Basic comparing algorithm */
if ((addr->data.normal.ipv6 && task->from_addr.af == AF_INET6) ||
- (!addr->data.normal.ipv6 && task->from_addr.af == AF_INET)) {
+ (!addr->data.normal.ipv6 && task->from_addr.af == AF_INET)) {
if (addr->data.normal.ipv6) {
addrlen = sizeof (struct in6_addr);
- memcpy (&in6s, &addr->data.normal.d.in6, sizeof (struct in6_addr));
- memcpy (&in6d, &task->from_addr.addr.s6.sin6_addr, sizeof (struct in6_addr));
+ memcpy (&in6s, &addr->data.normal.d.in6,
+ sizeof (struct in6_addr));
+ memcpy (&in6d, &task->from_addr.addr.s6.sin6_addr,
+ sizeof (struct in6_addr));
s = (guint8 *)&in6s;
d = (guint8 *)&in6d;
}
else {
addrlen = sizeof (struct in_addr);
- memcpy (&in4s, &addr->data.normal.d.in4, sizeof (struct in_addr));
- memcpy (&in4d, &task->from_addr.addr.s4.sin_addr, sizeof (struct in_addr));
+ memcpy (&in4s, &addr->data.normal.d.in4,
+ sizeof (struct in_addr));
+ memcpy (&in4d, &task->from_addr.addr.s4.sin_addr,
+ sizeof (struct in_addr));
s = (guint8 *)&in4s;
d = (guint8 *)&in4d;
}
s += addrlen - 1;
d += addrlen - 1;
/* TODO: improve this cycle by masking by words */
- for (nbits = 0; nbits < addrlen * CHAR_BIT - addr->data.normal.mask; nbits ++) {
+ for (nbits = 0;
+ nbits < addrlen * CHAR_BIT - addr->data.normal.mask;
+ nbits++) {
/* Skip bits from the beginning as we know that data is in network byte order */
if (nbits != 0 && nbits % 8 == 0) {
/* Move pointer to the next byte */
- s --;
- d --;
+ s--;
+ d--;
t = 0x1;
}
*s |= t;
if (res) {
switch (addr->mech) {
case SPF_FAIL:
- insert_result (task, spf_module_ctx->symbol_fail, 1, g_list_prepend (NULL, addr->spf_string));
+ insert_result (task,
+ spf_module_ctx->symbol_fail,
+ 1,
+ g_list_prepend (NULL, addr->spf_string));
task->messages = g_list_prepend (task->messages, "(SPF): spf fail");
break;
case SPF_SOFT_FAIL:
case SPF_NEUTRAL:
- insert_result (task, spf_module_ctx->symbol_softfail, 1, g_list_prepend (NULL, addr->spf_string));
- task->messages = g_list_prepend (task->messages, "(SPF): spf softfail");
+ insert_result (task,
+ spf_module_ctx->symbol_softfail,
+ 1,
+ g_list_prepend (NULL, addr->spf_string));
+ task->messages = g_list_prepend (task->messages,
+ "(SPF): spf softfail");
break;
default:
- insert_result (task, spf_module_ctx->symbol_allow, 1, g_list_prepend (NULL, addr->spf_string));
- task->messages = g_list_prepend (task->messages, "(SPF): spf allow");
+ insert_result (task,
+ spf_module_ctx->symbol_allow,
+ 1,
+ g_list_prepend (NULL, addr->spf_string));
+ task->messages =
+ g_list_prepend (task->messages, "(SPF): spf allow");
break;
}
return TRUE;
static gboolean
spf_check_list (GList *list, struct rspamd_task *task)
{
- GList *cur;
- struct spf_addr *addr;
+ GList *cur;
+ struct spf_addr *addr;
cur = list;
return FALSE;
}
-static void
+static void
spf_plugin_callback (struct spf_record *record, struct rspamd_task *task)
{
- GList *l;
+ GList *l;
if (record && record->addrs && record->sender_domain) {
- if ((l = rspamd_lru_hash_lookup (spf_module_ctx->spf_hash, record->sender_domain, task->tv.tv_sec)) == NULL) {
+ if ((l =
+ rspamd_lru_hash_lookup (spf_module_ctx->spf_hash,
+ record->sender_domain, task->tv.tv_sec)) == NULL) {
l = spf_record_copy (record->addrs);
- rspamd_lru_hash_insert (spf_module_ctx->spf_hash, g_strdup (record->sender_domain),
+ rspamd_lru_hash_insert (spf_module_ctx->spf_hash,
+ g_strdup (record->sender_domain),
l, task->tv.tv_sec, record->ttl);
}
spf_check_list (l, task);
}
-static void
+static void
spf_symbol_callback (struct rspamd_task *task, void *unused)
{
- gchar *domain;
- GList *l;
+ gchar *domain;
+ GList *l;
if (task->from_addr.af != AF_UNIX) {
domain = get_spf_domain (task);
if (domain) {
- if ((l = rspamd_lru_hash_lookup (spf_module_ctx->spf_hash, domain, task->tv.tv_sec)) != NULL) {
+ if ((l =
+ rspamd_lru_hash_lookup (spf_module_ctx->spf_hash, domain,
+ task->tv.tv_sec)) != NULL) {
spf_check_list (l, task);
}
else if (!resolve_spf (task, spf_plugin_callback)) {
static GList *
spf_record_copy (GList *addrs)
{
- GList *cur, *newl = NULL;
- struct spf_addr *addr, *newa;
+ GList *cur, *newl = NULL;
+ struct spf_addr *addr, *newa;
cur = addrs;
static void
spf_record_destroy (gpointer list)
{
- GList *cur = list;
- struct spf_addr *addr;
+ GList *cur = list;
+ struct spf_addr *addr;
while (cur) {
addr = cur->data;
* - bit (string): describes a prefix for a single bit
*/
+#include "cfg_file.h"
#include "config.h"
+#include "dns.h"
+#include "expressions.h"
+#include "hash.h"
#include "main.h"
+#include "map.h"
#include "message.h"
-#include "cfg_file.h"
-#include "expressions.h"
#include "util.h"
-#include "map.h"
-#include "dns.h"
-#include "hash.h"
#include "surbl.h"
-static struct surbl_ctx *surbl_module_ctx = NULL;
+static struct surbl_ctx *surbl_module_ctx = NULL;
static void surbl_test_url (struct rspamd_task *task, void *user_data);
static void dns_callback (struct rdns_reply *reply, gpointer arg);
static void process_dns_results (struct rspamd_task *task,
- struct suffix_item *suffix, gchar *url, guint32 addr);
+ struct suffix_item *suffix, gchar *url, guint32 addr);
-#define NO_REGEXP (gpointer)-1
+#define NO_REGEXP (gpointer) - 1
#define SURBL_ERROR surbl_error_quark ()
#define WHITELIST_ERROR 0
static void
exception_insert (gpointer st, gconstpointer key, gpointer value)
{
- GHashTable **t = st;
- gint level = 0;
- const gchar *p = key;
- f_str_t *val;
-
+ GHashTable **t = st;
+ gint level = 0;
+ const gchar *p = key;
+ f_str_t *val;
+
while (*p) {
if (*p == '.') {
- level ++;
+ level++;
}
- p ++;
+ p++;
}
if (level >= MAX_LEVELS) {
- msg_err ("invalid domain in exceptions list: %s, levels: %d", (gchar *)key, level);
+ msg_err ("invalid domain in exceptions list: %s, levels: %d",
+ (gchar *)key,
+ level);
return;
}
-
+
val = g_malloc (sizeof (f_str_t));
val->begin = (gchar *)key;
val->len = strlen (key);
if (t[level] == NULL) {
- t[level] = g_hash_table_new_full (fstr_strcase_hash, fstr_strcase_equal, g_free, NULL);
+ t[level] = g_hash_table_new_full (fstr_strcase_hash,
+ fstr_strcase_equal,
+ g_free,
+ NULL);
}
g_hash_table_insert (t[level], val, value);
}
static gchar *
-read_exceptions_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+read_exceptions_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
if (data->cur_data == NULL) {
- data->cur_data = rspamd_mempool_alloc0 (pool, sizeof (GHashTable *) * MAX_LEVELS);
+ data->cur_data = rspamd_mempool_alloc0 (pool,
+ sizeof (GHashTable *) * MAX_LEVELS);
}
- return abstract_parse_list (pool, chunk, len, data, (insert_func) exception_insert);
+ return abstract_parse_list (pool,
+ chunk,
+ len,
+ data,
+ (insert_func) exception_insert);
}
static void
fin_exceptions_list (rspamd_mempool_t * pool, struct map_cb_data *data)
{
- GHashTable **t;
- gint i;
+ GHashTable **t;
+ gint i;
if (data->prev_data) {
t = data->prev_data;
- for (i = 0; i < MAX_LEVELS; i ++) {
+ for (i = 0; i < MAX_LEVELS; i++) {
if (t[i] != NULL) {
g_hash_table_destroy (t[i]);
}
static void
redirector_insert (gpointer st, gconstpointer key, gpointer value)
{
- GHashTable *t = st;
- const gchar *p = key, *begin = key;
- gchar *new;
- gsize len;
- GRegex *re = NO_REGEXP;
- GError *err = NULL;
- guint idx;
+ GHashTable *t = st;
+ const gchar *p = key, *begin = key;
+ gchar *new;
+ gsize len;
+ GRegex *re = NO_REGEXP;
+ GError *err = NULL;
+ guint idx;
while (*p && !g_ascii_isspace (*p)) {
- p ++;
+ p++;
}
len = p - begin;
if (g_ascii_isspace (*p)) {
while (g_ascii_isspace (*p) && *p) {
- p ++;
+ p++;
}
if (*p) {
- re = g_regex_new (p, G_REGEX_RAW | G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE | G_REGEX_CASELESS,
- 0, &err);
+ re = g_regex_new (p,
+ G_REGEX_RAW | G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE | G_REGEX_CASELESS,
+ 0,
+ &err);
if (re == NULL) {
- msg_warn ("could not read regexp: %s while reading regexp %s", err->message, p);
+ msg_warn ("could not read regexp: %s while reading regexp %s",
+ err->message,
+ p);
re = NO_REGEXP;
}
}
static void
redirector_item_free (gpointer p)
{
- GRegex *re;
+ GRegex *re;
if (p != NULL && p != NO_REGEXP) {
re = (GRegex *)p;
g_regex_unref (re);
}
}
-static gchar *
-read_redirectors_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
+static gchar *
+read_redirectors_list (rspamd_mempool_t * pool,
+ gchar * chunk,
+ gint len,
+ struct map_cb_data *data)
{
if (data->cur_data == NULL) {
- data->cur_data = g_hash_table_new_full (rspamd_strcase_hash, rspamd_strcase_equal, g_free, redirector_item_free);
+ data->cur_data = g_hash_table_new_full (rspamd_strcase_hash,
+ rspamd_strcase_equal,
+ g_free,
+ redirector_item_free);
}
- return abstract_parse_list (pool, chunk, len, data, (insert_func) redirector_insert);
+ return abstract_parse_list (pool,
+ chunk,
+ len,
+ data,
+ (insert_func) redirector_insert);
}
void
surbl_module_ctx->use_redirector = 0;
surbl_module_ctx->suffixes = NULL;
- surbl_module_ctx->surbl_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ surbl_module_ctx->surbl_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
surbl_module_ctx->tld2_file = NULL;
surbl_module_ctx->whitelist_file = NULL;
surbl_module_ctx->redirector_trie = rspamd_trie_create (TRUE);
surbl_module_ctx->redirector_ptrs = g_ptr_array_new ();
- surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
- surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+ surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
+ surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
/* Zero exceptions hashes */
- surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (surbl_module_ctx->surbl_pool, MAX_LEVELS * sizeof (GHashTable *));
+ surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (
+ surbl_module_ctx->surbl_pool,
+ MAX_LEVELS * sizeof (GHashTable *));
/* Register destructors */
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->whitelist);
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->redirector_hosts);
-
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) rspamd_trie_free, surbl_module_ctx->redirector_trie);
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_ptr_array_unref, surbl_module_ctx->redirector_ptrs);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ surbl_module_ctx->whitelist);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ surbl_module_ctx->redirector_hosts);
+
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) rspamd_trie_free,
+ surbl_module_ctx->redirector_trie);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_ptr_array_unref,
+ surbl_module_ctx->redirector_ptrs);
*ctx = (struct module_ctx *)surbl_module_ctx;
static void
register_bit_symbols (struct rspamd_config *cfg, struct suffix_item *suffix)
{
- GList *cur;
- struct surbl_bit_item *bit;
+ GList *cur;
+ struct surbl_bit_item *bit;
if (suffix->bits != NULL) {
/* Prepend bit to symbol */
gint
surbl_module_config (struct rspamd_config *cfg)
{
- GList *cur_opt;
- struct suffix_item *new_suffix, *cur_suffix = NULL;
- struct surbl_bit_item *new_bit;
+ GList *cur_opt;
+ struct suffix_item *new_suffix, *cur_suffix = NULL;
+ struct surbl_bit_item *new_bit;
- const ucl_object_t *value, *cur, *cur_rule, *cur_bit;
- ucl_object_iter_t it = NULL;
- const gchar *redir_val;
- guint32 bit;
- gint i, idx;
+ const ucl_object_t *value, *cur, *cur_rule, *cur_bit;
+ ucl_object_iter_t it = NULL;
+ const gchar *redir_val;
+ guint32 bit;
+ gint i, idx;
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl", "redirector")) != NULL) {
i = 0;
- LL_FOREACH (value, cur) {
- i ++;
+ LL_FOREACH (value, cur)
+ {
+ i++;
}
- surbl_module_ctx->redirectors = rspamd_mempool_alloc0 (surbl_module_ctx->surbl_pool,
- i * sizeof (struct redirector_upstream));
+ surbl_module_ctx->redirectors = rspamd_mempool_alloc0 (
+ surbl_module_ctx->surbl_pool,
+ i * sizeof (struct redirector_upstream));
idx = 0;
- LL_FOREACH (value, cur) {
+ LL_FOREACH (value, cur)
+ {
redir_val = ucl_obj_tostring (cur);
surbl_module_ctx->redirectors[idx].up.priority = 100;
- if (! rspamd_parse_host_port_priority (surbl_module_ctx->surbl_pool,
- redir_val, &surbl_module_ctx->redirectors[idx].addr,
- &surbl_module_ctx->redirectors[idx].port,
- &surbl_module_ctx->redirectors[idx].up.priority)) {
+ if (!rspamd_parse_host_port_priority (surbl_module_ctx->surbl_pool,
+ redir_val, &surbl_module_ctx->redirectors[idx].addr,
+ &surbl_module_ctx->redirectors[idx].port,
+ &surbl_module_ctx->redirectors[idx].up.priority)) {
msg_warn ("invalid redirector definition: %s", redir_val);
}
else {
if (surbl_module_ctx->redirectors[idx].port != 0) {
- surbl_module_ctx->redirectors[idx].name = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+ surbl_module_ctx->redirectors[idx].name =
+ rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
redir_val);
- msg_info ("add redirector %s", surbl_module_ctx->redirectors[idx].name);
- idx ++;
+ msg_info ("add redirector %s",
+ surbl_module_ctx->redirectors[idx].name);
+ idx++;
}
}
- i ++;
+ i++;
}
surbl_module_ctx->redirectors_number = idx;
- surbl_module_ctx->use_redirector = (surbl_module_ctx->redirectors_number != 0);
+ surbl_module_ctx->use_redirector =
+ (surbl_module_ctx->redirectors_number != 0);
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_symbol")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl",
+ "redirector_symbol")) != NULL) {
surbl_module_ctx->redirector_symbol = ucl_obj_tostring (value);
- register_virtual_symbol (&cfg->cache, surbl_module_ctx->redirector_symbol, 1.0);
+ register_virtual_symbol (&cfg->cache,
+ surbl_module_ctx->redirector_symbol,
+ 1.0);
}
else {
surbl_module_ctx->redirector_symbol = NULL;
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "weight")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl", "weight")) != NULL) {
surbl_module_ctx->weight = ucl_obj_toint (value);
}
else {
surbl_module_ctx->weight = DEFAULT_SURBL_WEIGHT;
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "url_expire")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl", "url_expire")) != NULL) {
surbl_module_ctx->url_expire = ucl_obj_todouble (value);
}
else {
surbl_module_ctx->url_expire = DEFAULT_SURBL_URL_EXPIRE;
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_connect_timeout")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl",
+ "redirector_connect_timeout")) != NULL) {
surbl_module_ctx->connect_timeout = ucl_obj_todouble (value);
}
else {
surbl_module_ctx->connect_timeout = DEFAULT_REDIRECTOR_CONNECT_TIMEOUT;
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_read_timeout")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl",
+ "redirector_read_timeout")) != NULL) {
surbl_module_ctx->read_timeout = ucl_obj_todouble (value);
}
else {
surbl_module_ctx->read_timeout = DEFAULT_REDIRECTOR_READ_TIMEOUT;
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_hosts_map")) != NULL) {
- add_map (cfg, ucl_obj_tostring (value),
- "SURBL redirectors list", read_redirectors_list, fin_redirectors_list,
- (void **)&surbl_module_ctx->redirector_hosts);
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl",
+ "redirector_hosts_map")) != NULL) {
+ add_map (cfg, ucl_obj_tostring (
+ value),
+ "SURBL redirectors list", read_redirectors_list, fin_redirectors_list,
+ (void **)&surbl_module_ctx->redirector_hosts);
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "max_urls")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl", "max_urls")) != NULL) {
surbl_module_ctx->max_urls = ucl_obj_toint (value);
}
else {
surbl_module_ctx->max_urls = DEFAULT_SURBL_MAX_URLS;
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "exceptions")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl", "exceptions")) != NULL) {
if (add_map (cfg, ucl_obj_tostring (value),
- "SURBL exceptions list", read_exceptions_list, fin_exceptions_list,
- (void **)&surbl_module_ctx->exceptions)) {
- surbl_module_ctx->tld2_file = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
- ucl_obj_tostring (value) + sizeof ("file://") - 1);
+ "SURBL exceptions list", read_exceptions_list, fin_exceptions_list,
+ (void **)&surbl_module_ctx->exceptions)) {
+ surbl_module_ctx->tld2_file = rspamd_mempool_strdup (
+ surbl_module_ctx->surbl_pool,
+ ucl_obj_tostring (value) + sizeof ("file://") - 1);
}
}
- if ((value = rspamd_config_get_module_opt (cfg, "surbl", "whitelist")) != NULL) {
+ if ((value =
+ rspamd_config_get_module_opt (cfg, "surbl", "whitelist")) != NULL) {
if (add_map (cfg, ucl_obj_tostring (value),
- "SURBL whitelist", read_host_list, fin_host_list,
- (void **)&surbl_module_ctx->whitelist)) {
- surbl_module_ctx->whitelist_file = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
- ucl_obj_tostring (value) + sizeof ("file://") - 1);
+ "SURBL whitelist", read_host_list, fin_host_list,
+ (void **)&surbl_module_ctx->whitelist)) {
+ surbl_module_ctx->whitelist_file = rspamd_mempool_strdup (
+ surbl_module_ctx->surbl_pool,
+ ucl_obj_tostring (value) + sizeof ("file://") - 1);
}
}
value = rspamd_config_get_module_opt (cfg, "surbl", "rule");
if (value != NULL && value->type == UCL_OBJECT) {
- LL_FOREACH (value, cur_rule) {
+ LL_FOREACH (value, cur_rule)
+ {
cur = ucl_obj_get_key (cur_rule, "suffix");
if (cur == NULL) {
msg_err ("surbl rule must have explicit symbol definition");
continue;
}
- new_suffix = rspamd_mempool_alloc (surbl_module_ctx->surbl_pool, sizeof (struct suffix_item));
- new_suffix->suffix = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
- ucl_obj_tostring (cur));
+ new_suffix = rspamd_mempool_alloc (surbl_module_ctx->surbl_pool,
+ sizeof (struct suffix_item));
+ new_suffix->suffix = rspamd_mempool_strdup (
+ surbl_module_ctx->surbl_pool,
+ ucl_obj_tostring (cur));
new_suffix->options = 0;
new_suffix->bits = NULL;
cur = ucl_obj_get_key (cur_rule, "symbol");
if (cur == NULL) {
- msg_warn ("surbl rule for suffix %s lacks symbol, using %s as symbol", new_suffix->suffix,
- DEFAULT_SURBL_SYMBOL);
- new_suffix->symbol = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
- DEFAULT_SURBL_SYMBOL);
+ msg_warn (
+ "surbl rule for suffix %s lacks symbol, using %s as symbol",
+ new_suffix->suffix,
+ DEFAULT_SURBL_SYMBOL);
+ new_suffix->symbol = rspamd_mempool_strdup (
+ surbl_module_ctx->surbl_pool,
+ DEFAULT_SURBL_SYMBOL);
}
else {
- new_suffix->symbol = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
- ucl_obj_tostring (cur));
+ new_suffix->symbol = rspamd_mempool_strdup (
+ surbl_module_ctx->surbl_pool,
+ ucl_obj_tostring (cur));
}
cur = ucl_obj_get_key (cur_rule, "options");
if (cur != NULL && cur->type == UCL_STRING) {
cur = ucl_obj_get_key (cur_rule, "bits");
if (cur != NULL && cur->type == UCL_OBJECT) {
it = NULL;
- while ((cur_bit = ucl_iterate_object (cur, &it, true)) != NULL) {
- if (ucl_object_key (cur_bit) != NULL && cur_bit->type == UCL_INT) {
+ while ((cur_bit =
+ ucl_iterate_object (cur, &it, true)) != NULL) {
+ if (ucl_object_key (cur_bit) != NULL && cur_bit->type ==
+ UCL_INT) {
bit = ucl_obj_toint (cur_bit);
- new_bit = rspamd_mempool_alloc (surbl_module_ctx->surbl_pool, sizeof (struct surbl_bit_item));
+ new_bit = rspamd_mempool_alloc (
+ surbl_module_ctx->surbl_pool,
+ sizeof (struct surbl_bit_item));
new_bit->bit = bit;
- new_bit->symbol = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool, ucl_object_key (cur_bit));
- msg_debug ("add new bit suffix: %d with symbol: %s", (gint)new_bit->bit, new_bit->symbol);
- new_suffix->bits = g_list_prepend (new_suffix->bits, new_bit);
+ new_bit->symbol = rspamd_mempool_strdup (
+ surbl_module_ctx->surbl_pool,
+ ucl_object_key (cur_bit));
+ msg_debug ("add new bit suffix: %d with symbol: %s",
+ (gint)new_bit->bit, new_bit->symbol);
+ new_suffix->bits = g_list_prepend (new_suffix->bits,
+ new_bit);
}
}
}
- surbl_module_ctx->suffixes = g_list_prepend (surbl_module_ctx->suffixes, new_suffix);
- register_callback_symbol (&cfg->cache, new_suffix->symbol, 1, surbl_test_url, new_suffix);
+ surbl_module_ctx->suffixes = g_list_prepend (
+ surbl_module_ctx->suffixes,
+ new_suffix);
+ register_callback_symbol (&cfg->cache,
+ new_suffix->symbol,
+ 1,
+ surbl_test_url,
+ new_suffix);
}
}
/* Add default suffix */
}
if (surbl_module_ctx->suffixes != NULL) {
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_list_free,
- surbl_module_ctx->suffixes);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_list_free,
+ surbl_module_ctx->suffixes);
}
cur_opt = surbl_module_ctx->suffixes;
cur_suffix = cur_opt->data;
if (cur_suffix->bits != NULL) {
register_bit_symbols (cfg, cur_suffix);
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_list_free,
- cur_suffix->bits);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_list_free,
+ cur_suffix->bits);
}
cur_opt = g_list_next (cur_opt);
}
/* Reinit module */
surbl_module_ctx->use_redirector = 0;
surbl_module_ctx->suffixes = NULL;
- surbl_module_ctx->surbl_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+ surbl_module_ctx->surbl_pool = rspamd_mempool_new (
+ rspamd_mempool_suggest_size ());
surbl_module_ctx->tld2_file = NULL;
surbl_module_ctx->whitelist_file = NULL;
surbl_module_ctx->redirectors_number = 0;
surbl_module_ctx->redirector_trie = rspamd_trie_create (TRUE);
- surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
- surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+ surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
+ surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash,
+ rspamd_strcase_equal);
/* Zero exceptions hashes */
- surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (surbl_module_ctx->surbl_pool, MAX_LEVELS * sizeof (GHashTable *));
+ surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (
+ surbl_module_ctx->surbl_pool,
+ MAX_LEVELS * sizeof (GHashTable *));
/* Register destructors */
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->whitelist);
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->redirector_hosts);
-
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_list_free, surbl_module_ctx->suffixes);
-
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) rspamd_trie_free, surbl_module_ctx->redirector_trie);
- rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_ptr_array_unref, surbl_module_ctx->redirector_ptrs);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ surbl_module_ctx->whitelist);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_hash_table_destroy,
+ surbl_module_ctx->redirector_hosts);
+
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_list_free,
+ surbl_module_ctx->suffixes);
+
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) rspamd_trie_free,
+ surbl_module_ctx->redirector_trie);
+ rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
+ (rspamd_mempool_destruct_t) g_ptr_array_unref,
+ surbl_module_ctx->redirector_ptrs);
/* Perform configure */
return surbl_module_config (cfg);
-static gchar *
-format_surbl_request (rspamd_mempool_t * pool, f_str_t * hostname, struct suffix_item *suffix,
- gboolean append_suffix, GError ** err, gboolean forced, GTree *tree)
+static gchar *
+format_surbl_request (rspamd_mempool_t * pool,
+ f_str_t * hostname,
+ struct suffix_item *suffix,
+ gboolean append_suffix,
+ GError ** err,
+ gboolean forced,
+ GTree *tree)
{
- GHashTable *t;
- gchar *result = NULL, *dots[MAX_LEVELS], num_buf[sizeof("18446744073709551616")], *p;
- gint len, slen, r, i, dots_num = 0, level = MAX_LEVELS;
- gboolean is_numeric = TRUE;
- guint64 ip_num;
- f_str_t f;
+ GHashTable *t;
+ gchar *result = NULL, *dots[MAX_LEVELS],
+ num_buf[sizeof("18446744073709551616")], *p;
+ gint len, slen, r, i, dots_num = 0, level = MAX_LEVELS;
+ gboolean is_numeric = TRUE;
+ guint64 ip_num;
+ f_str_t f;
if (G_LIKELY (suffix != NULL)) {
slen = strlen (suffix->suffix);
g_assert_not_reached ();
}
len = hostname->len + slen + 2;
-
+
p = hostname->begin;
while (p - hostname->begin < (gint)hostname->len && dots_num < MAX_LEVELS) {
if (*p == '.') {
dots[dots_num] = p;
- dots_num ++;
+ dots_num++;
}
- else if (! g_ascii_isdigit (*p)) {
+ else if (!g_ascii_isdigit (*p)) {
is_numeric = FALSE;
}
- p ++;
+ p++;
}
-
+
/* Check for numeric expressions */
if (is_numeric && dots_num == 3) {
/* This is ip address */
return NULL;
}
result = rspamd_mempool_alloc (pool, len);
- r = rspamd_snprintf (result, len, "%*s.%*s.%*s.%*s",
+ r = rspamd_snprintf (result, len, "%*s.%*s.%*s.%*s",
(gint)(hostname->len - (dots[2] - hostname->begin + 1)),
dots[2] + 1,
(gint)(dots[2] - dots[1] - 1),
msg_info ("ignore request of ip url for list %s", suffix->symbol);
return NULL;
}
- rspamd_strlcpy (num_buf, hostname->begin, MIN (hostname->len + 1, sizeof (num_buf)));
+ rspamd_strlcpy (num_buf, hostname->begin,
+ MIN (hostname->len + 1, sizeof (num_buf)));
errno = 0;
ip_num = strtoull (num_buf, NULL, 10);
if (errno != 0) {
- msg_info ("cannot convert ip to number '%s': %s", num_buf, strerror (errno));
- g_set_error (err, SURBL_ERROR, /* error domain */
- CONVERSION_ERROR, /* error code */
+ msg_info ("cannot convert ip to number '%s': %s",
+ num_buf,
+ strerror (errno));
+ g_set_error (err, SURBL_ERROR, /* error domain */
+ CONVERSION_ERROR, /* error code */
"URL cannot be decoded");
return NULL;
}
/* Hack for bugged windows resolver */
ip_num &= 0xFFFFFFFF;
/* Get octets */
- r = rspamd_snprintf (result, len, "%ud.%ud.%ud.%ud",
- (guint32) ip_num & 0x000000FF, (guint32) (ip_num & 0x0000FF00) >> 8, (guint32) (ip_num & 0x00FF0000) >> 16, (guint32) (ip_num & 0xFF000000) >> 24);
+ r = rspamd_snprintf (result,
+ len,
+ "%ud.%ud.%ud.%ud",
+ (guint32) ip_num & 0x000000FF,
+ (guint32) (ip_num & 0x0000FF00) >> 8,
+ (guint32) (ip_num & 0x00FF0000) >> 16,
+ (guint32) (ip_num & 0xFF000000) >> 24);
}
else {
/* Not a numeric url */
result = rspamd_mempool_alloc (pool, len);
/* Now we should try to check for exceptions */
- if (! forced) {
- for (i = MAX_LEVELS - 1; i >= 0; i --) {
+ if (!forced) {
+ for (i = MAX_LEVELS - 1; i >= 0; i--) {
t = surbl_module_ctx->exceptions[i];
if (t != NULL && dots_num >= i + 1) {
f.begin = dots[dots_num - i - 1] + 1;
- f.len = hostname->len - (dots[dots_num - i - 1] - hostname->begin + 1);
+ f.len = hostname->len -
+ (dots[dots_num - i - 1] - hostname->begin + 1);
if (g_hash_table_lookup (t, &f) != NULL) {
level = dots_num - i - 1;
break;
}
if (level != MAX_LEVELS) {
if (level == 0) {
- r = rspamd_snprintf (result, len, "%*s", (gint)hostname->len, hostname->begin);
+ r = rspamd_snprintf (result,
+ len,
+ "%*s",
+ (gint)hostname->len,
+ hostname->begin);
}
else {
- r = rspamd_snprintf (result, len, "%*s",
- (gint)(hostname->len - (dots[level - 1] - hostname->begin + 1)),
- dots[level - 1] + 1);
+ r = rspamd_snprintf (result, len, "%*s",
+ (gint)(hostname->len -
+ (dots[level - 1] - hostname->begin + 1)),
+ dots[level - 1] + 1);
}
}
else if (dots_num >= 2) {
r = rspamd_snprintf (result, len, "%*s",
- (gint)(hostname->len - (dots[dots_num - 2] - hostname->begin + 1)),
+ (gint)(hostname->len -
+ (dots[dots_num - 2] - hostname->begin + 1)),
dots[dots_num - 2] + 1);
}
else {
- r = rspamd_snprintf (result, len, "%*s", (gint)hostname->len, hostname->begin);
+ r = rspamd_snprintf (result,
+ len,
+ "%*s",
+ (gint)hostname->len,
+ hostname->begin);
}
}
if (tree != NULL) {
if (g_tree_lookup (tree, result) != NULL) {
msg_debug ("url %s is already registered", result);
- g_set_error (err, SURBL_ERROR, /* error domain */
- DUPLICATE_ERROR, /* error code */
- "URL is duplicated: %s", /* error message format string */
- result);
+ g_set_error (err, SURBL_ERROR, /* error domain */
+ DUPLICATE_ERROR, /* error code */
+ "URL is duplicated: %s", /* error message format string */
+ result);
return NULL;
}
else {
}
}
- if (!forced && g_hash_table_lookup (surbl_module_ctx->whitelist, result) != NULL) {
+ if (!forced &&
+ g_hash_table_lookup (surbl_module_ctx->whitelist, result) != NULL) {
msg_debug ("url %s is whitelisted", result);
- g_set_error (err, SURBL_ERROR, /* error domain */
- WHITELIST_ERROR, /* error code */
- "URL is whitelisted: %s", /* error message format string */
- result);
+ g_set_error (err, SURBL_ERROR, /* error domain */
+ WHITELIST_ERROR, /* error code */
+ "URL is whitelisted: %s", /* error message format string */
+ result);
return NULL;
}
rspamd_snprintf (result + r, len - r, ".%s", suffix->suffix);
}
- msg_debug ("request: %s, dots: %d, level: %d, orig: %*s", result, dots_num, level, (gint)hostname->len, hostname->begin);
+ msg_debug ("request: %s, dots: %d, level: %d, orig: %*s",
+ result,
+ dots_num,
+ level,
+ (gint)hostname->len,
+ hostname->begin);
return result;
}
static void
make_surbl_requests (struct uri *url, struct rspamd_task *task,
- struct suffix_item *suffix, gboolean forced, GTree *tree)
+ struct suffix_item *suffix, gboolean forced, GTree *tree)
{
- gchar *surbl_req;
- f_str_t f;
- GError *err = NULL;
- struct dns_param *param;
+ gchar *surbl_req;
+ f_str_t f;
+ GError *err = NULL;
+ struct dns_param *param;
f.begin = url->host;
f.len = url->hostlen;
if ((surbl_req = format_surbl_request (task->task_pool, &f, suffix, TRUE,
- &err, forced, tree)) != NULL) {
- param = rspamd_mempool_alloc (task->task_pool, sizeof (struct dns_param));
+ &err, forced, tree)) != NULL) {
+ param =
+ rspamd_mempool_alloc (task->task_pool, sizeof (struct dns_param));
param->url = url;
param->task = task;
param->suffix = suffix;
- param->host_resolve = rspamd_mempool_strdup (task->task_pool, surbl_req);
+ param->host_resolve =
+ rspamd_mempool_strdup (task->task_pool, surbl_req);
debug_task ("send surbl dns request %s", surbl_req);
- if (make_dns_request (task->resolver, task->s, task->task_pool, dns_callback,
- (void *)param, RDNS_REQUEST_A, surbl_req)) {
- task->dns_requests ++;
+ if (make_dns_request (task->resolver, task->s, task->task_pool,
+ dns_callback,
+ (void *)param, RDNS_REQUEST_A, surbl_req)) {
+ task->dns_requests++;
}
}
- else if (err != NULL && err->code != WHITELIST_ERROR && err->code != DUPLICATE_ERROR) {
- msg_info ("cannot format url string for surbl %s, %s", struri (url), err->message);
+ else if (err != NULL && err->code != WHITELIST_ERROR && err->code !=
+ DUPLICATE_ERROR) {
+ msg_info ("cannot format url string for surbl %s, %s", struri (
+ url), err->message);
g_error_free (err);
return;
}
}
static void
-process_dns_results (struct rspamd_task *task, struct suffix_item *suffix, gchar *url, guint32 addr)
+process_dns_results (struct rspamd_task *task,
+ struct suffix_item *suffix,
+ gchar *url,
+ guint32 addr)
{
- GList *cur;
- struct surbl_bit_item *bit;
+ GList *cur;
+ struct surbl_bit_item *bit;
if (suffix->bits != NULL) {
cur = g_list_first (suffix->bits);
while (cur) {
bit = (struct surbl_bit_item *)cur->data;
- debug_task ("got result(%d) AND bit(%d): %d", (gint)addr, (gint)ntohl (bit->bit),
- (gint)bit->bit & (gint)ntohl (addr));
+ debug_task ("got result(%d) AND bit(%d): %d",
+ (gint)addr,
+ (gint)ntohl (bit->bit),
+ (gint)bit->bit & (gint)ntohl (addr));
if (((gint)bit->bit & (gint)ntohl (addr)) != 0) {
insert_result (task, bit->symbol, 1,
- g_list_prepend (NULL, rspamd_mempool_strdup (task->task_pool, url)));
+ g_list_prepend (NULL,
+ rspamd_mempool_strdup (task->task_pool, url)));
}
cur = g_list_next (cur);
}
}
else {
- insert_result (task, suffix->symbol, 1, g_list_prepend (NULL, rspamd_mempool_strdup (task->task_pool, url)));
+ insert_result (task, suffix->symbol, 1,
+ g_list_prepend (NULL,
+ rspamd_mempool_strdup (task->task_pool, url)));
}
}
static void
dns_callback (struct rdns_reply *reply, gpointer arg)
{
- struct dns_param *param = (struct dns_param *)arg;
- struct rspamd_task *task = param->task;
- struct rdns_reply_entry *elt;
+ struct dns_param *param = (struct dns_param *)arg;
+ struct rspamd_task *task = param->task;
+ struct rdns_reply_entry *elt;
debug_task ("in surbl request callback");
/* If we have result from DNS server, this url exists in SURBL, so increase score */
if (reply->code == RDNS_RC_NOERROR && reply->entries) {
msg_info ("<%s> domain [%s] is in surbl %s", param->task->message_id,
- param->host_resolve, param->suffix->suffix);
+ param->host_resolve, param->suffix->suffix);
elt = reply->entries;
if (elt->type == RDNS_REQUEST_A) {
process_dns_results (param->task, param->suffix,
- param->host_resolve, (guint32)elt->content.a.addr.s_addr);
+ param->host_resolve, (guint32)elt->content.a.addr.s_addr);
}
}
else {
debug_task ("<%s> domain [%s] is not in surbl %s",
- param->task->message_id, param->host_resolve, param->suffix->suffix);
+ param->task->message_id, param->host_resolve,
+ param->suffix->suffix);
}
}
static void
free_redirector_session (void *ud)
{
- struct redirector_param *param = (struct redirector_param *)ud;
+ struct redirector_param *param = (struct redirector_param *)ud;
event_del (¶m->ev);
g_string_free (param->buf, TRUE);
static void
redirector_callback (gint fd, short what, void *arg)
{
- struct redirector_param *param = (struct redirector_param *)arg;
- struct rspamd_task *task = param->task;
- gchar url_buf[512];
- gint r;
- struct timeval *timeout;
- gchar *p, *c;
- gboolean found = FALSE;
+ struct redirector_param *param = (struct redirector_param *)arg;
+ struct rspamd_task *task = param->task;
+ gchar url_buf[512];
+ gint r;
+ struct timeval *timeout;
+ gchar *p, *c;
+ gboolean found = FALSE;
switch (param->state) {
case STATE_CONNECT:
/* We have write readiness after connect call, so reinit event */
if (what == EV_WRITE) {
- timeout = rspamd_mempool_alloc (param->task->task_pool, sizeof (struct timeval));
+ timeout =
+ rspamd_mempool_alloc (param->task->task_pool,
+ sizeof (struct timeval));
timeout->tv_sec = surbl_module_ctx->read_timeout / 1000;
- timeout->tv_usec = (surbl_module_ctx->read_timeout - timeout->tv_sec * 1000) * 1000;
+ timeout->tv_usec =
+ (surbl_module_ctx->read_timeout - timeout->tv_sec *
+ 1000) * 1000;
event_del (¶m->ev);
- event_set (¶m->ev, param->sock, EV_READ | EV_PERSIST, redirector_callback, (void *)param);
+ event_set (¶m->ev,
+ param->sock,
+ EV_READ | EV_PERSIST,
+ redirector_callback,
+ (void *)param);
event_add (¶m->ev, timeout);
- r = rspamd_snprintf (url_buf, sizeof (url_buf), "GET %s HTTP/1.0\r\n\r\n", struri (param->url));
+ r = rspamd_snprintf (url_buf,
+ sizeof (url_buf),
+ "GET %s HTTP/1.0\r\n\r\n",
+ struri (param->url));
if (write (param->sock, url_buf, r) == -1) {
- msg_err ("write failed %s to %s", strerror (errno), param->redirector->name);
+ msg_err ("write failed %s to %s", strerror (
+ errno), param->redirector->name);
upstream_fail (¶m->redirector->up, param->task->tv.tv_sec);
- remove_normal_event (param->task->s, free_redirector_session, param);
+ remove_normal_event (param->task->s,
+ free_redirector_session,
+ param);
return;
}
param->state = STATE_READ;
}
else {
- msg_info ("<%s> connection to redirector %s timed out while waiting for write",
- param->task->message_id, param->redirector->name);
+ msg_info (
+ "<%s> connection to redirector %s timed out while waiting for write",
+ param->task->message_id,
+ param->redirector->name);
upstream_fail (¶m->redirector->up, param->task->tv.tv_sec);
- remove_normal_event (param->task->s, free_redirector_session, param);
+ remove_normal_event (param->task->s, free_redirector_session,
+ param);
return;
}
if (what == EV_READ) {
r = read (param->sock, url_buf, sizeof (url_buf) - 1);
if (r <= 0) {
- msg_err ("read failed: %s from %s", strerror (errno), param->redirector->name);
+ msg_err ("read failed: %s from %s", strerror (
+ errno), param->redirector->name);
upstream_fail (¶m->redirector->up, param->task->tv.tv_sec);
- make_surbl_requests (param->url, param->task, param->suffix, FALSE, param->tree);
- remove_normal_event (param->task->s, free_redirector_session, param);
+ make_surbl_requests (param->url,
+ param->task,
+ param->suffix,
+ FALSE,
+ param->tree);
+ remove_normal_event (param->task->s,
+ free_redirector_session,
+ param);
return;
}
}
}
if (found) {
- debug_task ("<%s> got reply from redirector: '%s' -> '%s'", param->task->message_id, struri (param->url), c);
- r = parse_uri (param->url, rspamd_mempool_strdup (param->task->task_pool, c), param->task->task_pool);
- if (r == URI_ERRNO_OK || r == URI_ERRNO_NO_SLASHES || r == URI_ERRNO_NO_HOST_SLASH) {
- make_surbl_requests (param->url, param->task, param->suffix, FALSE, param->tree);
+ debug_task ("<%s> got reply from redirector: '%s' -> '%s'",
+ param->task->message_id,
+ struri (param->url),
+ c);
+ r =
+ parse_uri (param->url,
+ rspamd_mempool_strdup (param->task->task_pool,
+ c), param->task->task_pool);
+ if (r == URI_ERRNO_OK || r == URI_ERRNO_NO_SLASHES || r ==
+ URI_ERRNO_NO_HOST_SLASH) {
+ make_surbl_requests (param->url,
+ param->task,
+ param->suffix,
+ FALSE,
+ param->tree);
}
}
}
upstream_ok (¶m->redirector->up, param->task->tv.tv_sec);
- remove_normal_event (param->task->s, free_redirector_session, param);
+ remove_normal_event (param->task->s, free_redirector_session,
+ param);
}
else {
- msg_info ("<%s> reading redirector %s timed out, while waiting for read",
- param->redirector->name, param->task->message_id);
+ msg_info (
+ "<%s> reading redirector %s timed out, while waiting for read",
+ param->redirector->name,
+ param->task->message_id);
upstream_fail (¶m->redirector->up, param->task->tv.tv_sec);
- remove_normal_event (param->task->s, free_redirector_session, param);
+ remove_normal_event (param->task->s, free_redirector_session,
+ param);
}
break;
}
static void
register_redirector_call (struct uri *url, struct rspamd_task *task,
- struct suffix_item *suffix, const gchar *rule, GTree *tree)
+ struct suffix_item *suffix, const gchar *rule, GTree *tree)
{
- gint s = -1;
- struct redirector_param *param;
- struct timeval *timeout;
- struct redirector_upstream *selected;
-
- selected = (struct redirector_upstream *)get_upstream_round_robin (surbl_module_ctx->redirectors,
- surbl_module_ctx->redirectors_number,
- sizeof (struct redirector_upstream),
- task->tv.tv_sec, DEFAULT_UPSTREAM_ERROR_TIME,
- DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
+ gint s = -1;
+ struct redirector_param *param;
+ struct timeval *timeout;
+ struct redirector_upstream *selected;
+
+ selected = (struct redirector_upstream *)get_upstream_round_robin (
+ surbl_module_ctx->redirectors,
+ surbl_module_ctx->redirectors_number,
+ sizeof (struct redirector_upstream),
+ task->tv.tv_sec,
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS);
if (selected) {
- s = make_universal_socket (selected->addr, selected->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+ s = make_universal_socket (selected->addr,
+ selected->port,
+ SOCK_STREAM,
+ TRUE,
+ FALSE,
+ FALSE);
}
if (s == -1) {
- msg_info ("<%s> cannot create tcp socket failed: %s", task->message_id, strerror (errno));
+ msg_info ("<%s> cannot create tcp socket failed: %s",
+ task->message_id,
+ strerror (errno));
make_surbl_requests (url, task, suffix, FALSE, tree);
return;
}
- param = rspamd_mempool_alloc (task->task_pool, sizeof (struct redirector_param));
+ param =
+ rspamd_mempool_alloc (task->task_pool,
+ sizeof (struct redirector_param));
param->url = url;
param->task = task;
param->state = STATE_CONNECT;
param->tree = tree;
timeout = rspamd_mempool_alloc (task->task_pool, sizeof (struct timeval));
timeout->tv_sec = surbl_module_ctx->connect_timeout / 1000;
- timeout->tv_usec = (surbl_module_ctx->connect_timeout - timeout->tv_sec * 1000) * 1000;
+ timeout->tv_usec =
+ (surbl_module_ctx->connect_timeout - timeout->tv_sec * 1000) * 1000;
event_set (¶m->ev, s, EV_WRITE, redirector_callback, (void *)param);
event_add (¶m->ev, timeout);
- register_async_event (task->s, free_redirector_session, param, g_quark_from_static_string ("surbl"));
-
- msg_info ("<%s> registered redirector call for %s to %s, according to rule: %s",
- task->message_id, struri (url), selected->name, rule);
+ register_async_event (task->s,
+ free_redirector_session,
+ param,
+ g_quark_from_static_string ("surbl"));
+
+ msg_info (
+ "<%s> registered redirector call for %s to %s, according to rule: %s",
+ task->message_id,
+ struri (url),
+ selected->name,
+ rule);
}
-static gboolean
+static gboolean
surbl_tree_url_callback (gpointer key, gpointer value, void *data)
{
- struct redirector_param *param = data;
- struct rspamd_task *task;
- struct uri *url = value;
- gchar *red_domain;
- const gchar *pos;
- GRegex *re;
- guint idx, len;
+ struct redirector_param *param = data;
+ struct rspamd_task *task;
+ struct uri *url = value;
+ gchar *red_domain;
+ const gchar *pos;
+ GRegex *re;
+ guint idx, len;
task = param->task;
debug_task ("check url %s", struri (url));
if (surbl_module_ctx->use_redirector) {
/* Search in trie */
if (surbl_module_ctx->redirector_trie &&
- (pos = rspamd_trie_lookup (surbl_module_ctx->redirector_trie, url->host, url->hostlen, &idx)) != NULL &&
- idx < surbl_module_ctx->redirector_ptrs->len) {
+ (pos =
+ rspamd_trie_lookup (surbl_module_ctx->redirector_trie, url->host,
+ url->hostlen, &idx)) != NULL &&
+ idx < surbl_module_ctx->redirector_ptrs->len) {
/* Get corresponding prefix */
- red_domain = g_ptr_array_index (surbl_module_ctx->redirector_ptrs, idx);
+ red_domain = g_ptr_array_index (surbl_module_ctx->redirector_ptrs,
+ idx);
if (red_domain != NULL) {
len = strlen (red_domain);
/* First check that we have found domain at the end of host */
if (pos + len == url->host + url->hostlen &&
(pos == url->host || *(pos - 1) == '.')) {
/* Try to find corresponding regexp */
- re = g_hash_table_lookup (surbl_module_ctx->redirector_hosts, red_domain);
- if (re != NULL && (re == NO_REGEXP || g_regex_match (re, url->string, 0, NULL))) {
+ re = g_hash_table_lookup (
+ surbl_module_ctx->redirector_hosts,
+ red_domain);
+ if (re != NULL &&
+ (re == NO_REGEXP ||
+ g_regex_match (re, url->string, 0, NULL))) {
/* If no regexp found or founded regexp matches url string register redirector's call */
if (surbl_module_ctx->redirector_symbol != NULL) {
- insert_result (param->task, surbl_module_ctx->redirector_symbol, 1, g_list_prepend (NULL, red_domain));
+ insert_result (param->task,
+ surbl_module_ctx->redirector_symbol,
+ 1,
+ g_list_prepend (NULL, red_domain));
}
- register_redirector_call (url, param->task, param->suffix, red_domain, param->tree);
+ register_redirector_call (url,
+ param->task,
+ param->suffix,
+ red_domain,
+ param->tree);
return FALSE;
}
}
}
}
- make_surbl_requests (url, param->task, param->suffix, FALSE, param->tree);
+ make_surbl_requests (url, param->task, param->suffix, FALSE,
+ param->tree);
}
else {
- make_surbl_requests (url, param->task, param->suffix, FALSE, param->tree);
+ make_surbl_requests (url, param->task, param->suffix, FALSE,
+ param->tree);
}
return FALSE;
static void
surbl_test_url (struct rspamd_task *task, void *user_data)
{
- struct redirector_param param;
- struct suffix_item *suffix = user_data;
+ struct redirector_param param;
+ struct suffix_item *suffix = user_data;
param.task = task;
param.suffix = suffix;
param.tree = g_tree_new ((GCompareFunc)strcmp);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_tree_destroy, param.tree);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t)g_tree_destroy,
+ param.tree);
g_tree_foreach (task->urls, surbl_tree_url_callback, ¶m);
}
/*
*/
#if 0
struct urls_tree_cb_data {
- gchar *buf;
- gsize len;
- gsize off;
- struct rspamd_task *task;
+ gchar *buf;
+ gsize len;
+ gsize off;
+ struct rspamd_task *task;
};
static gboolean
calculate_buflen_cb (gpointer key, gpointer value, gpointer cbdata)
{
- struct urls_tree_cb_data *cb = cbdata;
- struct uri *url = value;
+ struct urls_tree_cb_data *cb = cbdata;
+ struct uri *url = value;
cb->len += strlen (struri (url)) + url->hostlen + sizeof (" <\"\">, ") - 1;
static gboolean
write_urls_buffer (gpointer key, gpointer value, gpointer cbdata)
{
- struct urls_tree_cb_data *cb = cbdata;
- struct uri *url = value;
- f_str_t f;
- gchar *urlstr;
- gsize len;
+ struct urls_tree_cb_data *cb = cbdata;
+ struct uri *url = value;
+ f_str_t f;
+ gchar *urlstr;
+ gsize len;
f.begin = url->host;
f.len = url->hostlen;
- if ((urlstr = format_surbl_request (cb->task->task_pool, &f, NULL, FALSE, NULL, FALSE)) != NULL) {
+ if ((urlstr =
+ format_surbl_request (cb->task->task_pool, &f, NULL, FALSE, NULL,
+ FALSE)) != NULL) {
len = strlen (urlstr);
if (cb->off + len >= cb->len) {
- msg_info ("cannot write urls header completely, stripped reply at: %z", cb->off);
+ msg_info (
+ "cannot write urls header completely, stripped reply at: %z",
+ cb->off);
return TRUE;
}
else {
- cb->off += rspamd_snprintf (cb->buf + cb->off, cb->len - cb->off, " %s <\"%s\">,",
- urlstr, struri (url));
+ cb->off += rspamd_snprintf (cb->buf + cb->off,
+ cb->len - cb->off,
+ " %s <\"%s\">,",
+ urlstr,
+ struri (url));
}
}
static gboolean
urls_command_handler (struct rspamd_task *task)
{
- struct urls_tree_cb_data cb;
+ struct urls_tree_cb_data cb;
/* First calculate buffer length */
cb.len = sizeof (RSPAMD_REPLY_BANNER "/1.0 0 " SPAMD_OK CRLF "Urls: " CRLF);
g_tree_foreach (task->urls, calculate_buflen_cb, &cb);
cb.buf = rspamd_mempool_alloc (task->task_pool, cb.len * sizeof (gchar));
- cb.off += rspamd_snprintf (cb.buf + cb.off, cb.len - cb.off, "%s/%s 0 %s" CRLF "Urls:",
- (task->proto == SPAMC_PROTO) ? SPAMD_REPLY_BANNER : RSPAMD_REPLY_BANNER,
- "1.3", SPAMD_OK);
+ cb.off += rspamd_snprintf (cb.buf + cb.off,
+ cb.len - cb.off,
+ "%s/%s 0 %s" CRLF "Urls:",
+ (task->proto == SPAMC_PROTO) ? SPAMD_REPLY_BANNER : RSPAMD_REPLY_BANNER,
+ "1.3",
+ SPAMD_OK);
cb.task = task;
/* Write urls to buffer */
cb.buf[--cb.off] = '\0';
}
/* Write result */
- if (! rspamd_dispatcher_write (task->dispatcher, cb.buf, cb.off, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (task->dispatcher, cb.buf, cb.off, FALSE,
+ TRUE)) {
return FALSE;
}
- if (!rspamd_dispatcher_write (task->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (task->dispatcher, CRLF, sizeof (CRLF) - 1,
+ FALSE, TRUE)) {
return FALSE;
}
task->state = STATE_REPLY;
}
#endif
/*
- * vi:ts=4
+ * vi:ts=4
*/
#ifndef RSPAMD_MODULE_SURBL
#define RSPAMD_MODULE_SURBL
+#include "cfg_file.h"
#include "config.h"
#include "main.h"
-#include "cfg_file.h"
#include "trie.h"
#define DEFAULT_REDIRECTOR_PORT 8080
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "config.h"
-#include "main.h"
#include "cfg_file.h"
#include "cfg_xml.h"
-#include "util.h"
-#include "smtp.h"
-#include "smtp_proto.h"
-#include "smtp_utils.h"
+#include "config.h"
+#include "dns.h"
+#include "lua/lua_common.h"
+#include "main.h"
#include "map.h"
#include "message.h"
#include "settings.h"
-#include "dns.h"
-#include "lua/lua_common.h"
+#include "smtp.h"
+#include "smtp_proto.h"
+#include "smtp_utils.h"
+#include "util.h"
/* Max line size as it is defined in rfc2822 */
#define OUTBUFSIZ 1000
void start_smtp (struct rspamd_worker *worker);
worker_t smtp_worker = {
- "smtp", /* Name */
- init_smtp, /* Init function */
- start_smtp, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE, /* Killable */
- SOCK_STREAM /* TCP socket */
+ "smtp", /* Name */
+ init_smtp, /* Init function */
+ start_smtp, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE, /* Killable */
+ SOCK_STREAM /* TCP socket */
};
static gboolean
call_stage_filters (struct smtp_session *session, enum rspamd_smtp_stage stage)
{
- gboolean res = TRUE;
- GList *list = session->ctx->smtp_filters[stage];
- struct smtp_filter *filter;
-
+ gboolean res = TRUE;
+ GList *list = session->ctx->smtp_filters[stage];
+ struct smtp_filter *filter;
+
while (list) {
filter = list->data;
- if (! filter->filter (session, filter->filter_data)) {
+ if (!filter->filter (session, filter->filter_data)) {
res = FALSE;
break;
}
static gboolean
read_smtp_command (struct smtp_session *session, f_str_t *line)
{
- struct smtp_command *cmd;
- gchar outbuf[BUFSIZ];
- gint r;
-
- if (! parse_smtp_command (session, line, &cmd)) {
+ struct smtp_command *cmd;
+ gchar outbuf[BUFSIZ];
+ gint r;
+
+ if (!parse_smtp_command (session, line, &cmd)) {
session->error = SMTP_ERROR_BAD_COMMAND;
- session->errors ++;
+ session->errors++;
return FALSE;
}
-
+
switch (cmd->command) {
- case SMTP_COMMAND_HELO:
- case SMTP_COMMAND_EHLO:
- if (session->state == SMTP_STATE_GREETING || session->state == SMTP_STATE_HELO) {
- if (parse_smtp_helo (session, cmd)) {
- session->state = SMTP_STATE_FROM;
- }
- else {
- session->errors ++;
- }
- if (! call_stage_filters (session, SMTP_STAGE_HELO)) {
- return FALSE;
- }
- return TRUE;
+ case SMTP_COMMAND_HELO:
+ case SMTP_COMMAND_EHLO:
+ if (session->state == SMTP_STATE_GREETING || session->state ==
+ SMTP_STATE_HELO) {
+ if (parse_smtp_helo (session, cmd)) {
+ session->state = SMTP_STATE_FROM;
}
else {
- goto improper_sequence;
+ session->errors++;
}
- break;
- case SMTP_COMMAND_QUIT:
- session->state = SMTP_STATE_QUIT;
- break;
- case SMTP_COMMAND_NOOP:
- break;
- case SMTP_COMMAND_MAIL:
- if (((session->state == SMTP_STATE_GREETING || session->state == SMTP_STATE_HELO) && !session->ctx->helo_required)
- || session->state == SMTP_STATE_FROM) {
- if (parse_smtp_from (session, cmd)) {
- session->state = SMTP_STATE_RCPT;
- }
- else {
- session->errors ++;
- return FALSE;
- }
- if (! call_stage_filters (session, SMTP_STAGE_MAIL)) {
- return FALSE;
- }
+ if (!call_stage_filters (session, SMTP_STAGE_HELO)) {
+ return FALSE;
+ }
+ return TRUE;
+ }
+ else {
+ goto improper_sequence;
+ }
+ break;
+ case SMTP_COMMAND_QUIT:
+ session->state = SMTP_STATE_QUIT;
+ break;
+ case SMTP_COMMAND_NOOP:
+ break;
+ case SMTP_COMMAND_MAIL:
+ if (((session->state == SMTP_STATE_GREETING || session->state ==
+ SMTP_STATE_HELO) && !session->ctx->helo_required)
+ || session->state == SMTP_STATE_FROM) {
+ if (parse_smtp_from (session, cmd)) {
+ session->state = SMTP_STATE_RCPT;
}
else {
- goto improper_sequence;
+ session->errors++;
+ return FALSE;
}
- break;
- case SMTP_COMMAND_RCPT:
- if (session->state == SMTP_STATE_RCPT) {
- if (parse_smtp_rcpt (session, cmd)) {
- if (! call_stage_filters (session, SMTP_STAGE_RCPT)) {
+ if (!call_stage_filters (session, SMTP_STAGE_MAIL)) {
+ return FALSE;
+ }
+ }
+ else {
+ goto improper_sequence;
+ }
+ break;
+ case SMTP_COMMAND_RCPT:
+ if (session->state == SMTP_STATE_RCPT) {
+ if (parse_smtp_rcpt (session, cmd)) {
+ if (!call_stage_filters (session, SMTP_STAGE_RCPT)) {
+ return FALSE;
+ }
+ /* Make upstream connection */
+ if (session->upstream == NULL) {
+ if (!create_smtp_upstream_connection (session)) {
+ session->error = SMTP_ERROR_UPSTREAM;
+ session->state = SMTP_STATE_CRITICAL_ERROR;
return FALSE;
}
- /* Make upstream connection */
- if (session->upstream == NULL) {
- if (!create_smtp_upstream_connection (session)) {
- session->error = SMTP_ERROR_UPSTREAM;
- session->state = SMTP_STATE_CRITICAL_ERROR;
- return FALSE;
- }
- }
- else {
- /* Send next rcpt to upstream */
- session->state = SMTP_STATE_WAIT_UPSTREAM;
- session->upstream_state = SMTP_STATE_BEFORE_DATA;
- rspamd_dispatcher_restore (session->upstream_dispatcher);
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
- r += smtp_upstream_write_list (session->rcpt->data, outbuf + r, sizeof (outbuf) - r);
- session->cur_rcpt = NULL;
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
- }
- session->state = SMTP_STATE_WAIT_UPSTREAM;
- return TRUE;
}
else {
- session->errors ++;
- return FALSE;
+ /* Send next rcpt to upstream */
+ session->state = SMTP_STATE_WAIT_UPSTREAM;
+ session->upstream_state = SMTP_STATE_BEFORE_DATA;
+ rspamd_dispatcher_restore (session->upstream_dispatcher);
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
+ r += smtp_upstream_write_list (session->rcpt->data,
+ outbuf + r,
+ sizeof (outbuf) - r);
+ session->cur_rcpt = NULL;
+ return rspamd_dispatcher_write (
+ session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
}
+ session->state = SMTP_STATE_WAIT_UPSTREAM;
+ return TRUE;
}
else {
- goto improper_sequence;
+ session->errors++;
+ return FALSE;
}
- break;
- case SMTP_COMMAND_RSET:
- session->from = NULL;
- if (session->rcpt) {
- g_list_free (session->rcpt);
+ }
+ else {
+ goto improper_sequence;
+ }
+ break;
+ case SMTP_COMMAND_RSET:
+ session->from = NULL;
+ if (session->rcpt) {
+ g_list_free (session->rcpt);
+ }
+ if (session->upstream) {
+ remove_normal_event (session->s,
+ smtp_upstream_finalize_connection,
+ session);
+ session->upstream = NULL;
+ }
+ session->state = SMTP_STATE_GREETING;
+ break;
+ case SMTP_COMMAND_DATA:
+ if (session->state == SMTP_STATE_RCPT) {
+ if (session->rcpt == NULL) {
+ session->error = SMTP_ERROR_RECIPIENTS;
+ session->errors++;
+ return FALSE;
}
- if (session->upstream) {
- remove_normal_event (session->s, smtp_upstream_finalize_connection, session);
- session->upstream = NULL;
+ if (!call_stage_filters (session, SMTP_STAGE_DATA)) {
+ return FALSE;
}
- session->state = SMTP_STATE_GREETING;
- break;
- case SMTP_COMMAND_DATA:
- if (session->state == SMTP_STATE_RCPT) {
- if (session->rcpt == NULL) {
- session->error = SMTP_ERROR_RECIPIENTS;
- session->errors ++;
- return FALSE;
- }
- if (! call_stage_filters (session, SMTP_STAGE_DATA)) {
- return FALSE;
- }
- if (session->upstream == NULL) {
- session->error = SMTP_ERROR_UPSTREAM;
- session->state = SMTP_STATE_CRITICAL_ERROR;
- return FALSE;
- }
- else {
- session->upstream_state = SMTP_STATE_DATA;
- rspamd_dispatcher_restore (session->upstream_dispatcher);
- r = rspamd_snprintf (outbuf, sizeof (outbuf), "DATA" CRLF);
- session->state = SMTP_STATE_WAIT_UPSTREAM;
- session->error = SMTP_ERROR_DATA_OK;
- return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
- }
+ if (session->upstream == NULL) {
+ session->error = SMTP_ERROR_UPSTREAM;
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ return FALSE;
}
else {
- goto improper_sequence;
+ session->upstream_state = SMTP_STATE_DATA;
+ rspamd_dispatcher_restore (session->upstream_dispatcher);
+ r = rspamd_snprintf (outbuf, sizeof (outbuf), "DATA" CRLF);
+ session->state = SMTP_STATE_WAIT_UPSTREAM;
+ session->error = SMTP_ERROR_DATA_OK;
+ return rspamd_dispatcher_write (session->upstream_dispatcher,
+ outbuf,
+ r,
+ FALSE,
+ FALSE);
}
- case SMTP_COMMAND_VRFY:
- case SMTP_COMMAND_EXPN:
- case SMTP_COMMAND_HELP:
- session->error = SMTP_ERROR_UNIMPLIMENTED;
- return FALSE;
+ }
+ else {
+ goto improper_sequence;
+ }
+ case SMTP_COMMAND_VRFY:
+ case SMTP_COMMAND_EXPN:
+ case SMTP_COMMAND_HELP:
+ session->error = SMTP_ERROR_UNIMPLIMENTED;
+ return FALSE;
}
-
+
session->error = SMTP_ERROR_OK;
return TRUE;
improper_sequence:
- session->errors ++;
+ session->errors++;
session->error = SMTP_ERROR_SEQUENCE;
return FALSE;
}
static gboolean
process_smtp_data (struct smtp_session *session)
{
- struct stat st;
- gint r;
- GList *cur, *t;
- f_str_t *f;
- gchar *s;
+ struct stat st;
+ gint r;
+ GList *cur, *t;
+ f_str_t *f;
+ gchar *s;
if (fstat (session->temp_fd, &st) == -1) {
msg_err ("fstat failed: %s", strerror (errno));
}
/* Now mmap temp file if it is small enough */
session->temp_size = st.st_size;
- if (session->ctx->max_size == 0 || st.st_size < (off_t)session->ctx->max_size) {
+ if (session->ctx->max_size == 0 || st.st_size <
+ (off_t)session->ctx->max_size) {
session->task = rspamd_task_new (session->worker);
session->task->resolver = session->resolver;
session->task->fin_callback = smtp_write_socket;
session->task->fin_arg = session;
- session->task->msg = rspamd_mempool_alloc (session->pool, sizeof (GString));
+ session->task->msg =
+ rspamd_mempool_alloc (session->pool, sizeof (GString));
session->task->s = session->s;
#ifdef HAVE_MMAP_NOCORE
- if ((session->task->msg->str = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED | MAP_NOCORE, session->temp_fd, 0)) == MAP_FAILED) {
+ if ((session->task->msg->str =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED | MAP_NOCORE,
+ session->temp_fd, 0)) == MAP_FAILED) {
#else
- if ((session->task->msg->str = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, session->temp_fd, 0)) == MAP_FAILED) {
+ if ((session->task->msg->str =
+ mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, session->temp_fd,
+ 0)) == MAP_FAILED) {
#endif
msg_err ("mmap failed: %s", strerror (errno));
goto err;
t = g_list_next (t);
}
- memcpy (&session->task->from_addr, &session->client_addr, sizeof (struct in_addr));
+ memcpy (&session->task->from_addr, &session->client_addr,
+ sizeof (struct in_addr));
session->task->cmd = CMD_CHECK;
if (process_message (session->task) == -1) {
}
}
else {
- msg_info ("not scan message as it is %z bytes and maximum is %z", st.st_size, session->ctx->max_size);
+ msg_info ("not scan message as it is %z bytes and maximum is %z",
+ st.st_size,
+ session->ctx->max_size);
session->task = NULL;
return smtp_send_upstream_message (session);
}
err:
session->error = SMTP_ERROR_FILE;
session->state = SMTP_STATE_CRITICAL_ERROR;
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
+ TRUE)) {
return FALSE;
}
destroy_session (session->s);
/*
* Callback that is called when there is data to read in buffer
*/
-static gboolean
+static gboolean
smtp_read_socket (f_str_t * in, void *arg)
{
- struct smtp_session *session = arg;
+ struct smtp_session *session = arg;
switch (session->state) {
- case SMTP_STATE_RESOLVE_REVERSE:
- case SMTP_STATE_RESOLVE_NORMAL:
- case SMTP_STATE_DELAY:
- session->error = make_smtp_error (session->pool, 550, "%s Improper use of SMTP command pipelining", "5.5.0");
- session->state = SMTP_STATE_ERROR;
- break;
- case SMTP_STATE_GREETING:
- case SMTP_STATE_HELO:
- case SMTP_STATE_FROM:
- case SMTP_STATE_RCPT:
- case SMTP_STATE_DATA:
- read_smtp_command (session, in);
- if (session->state != SMTP_STATE_WAIT_UPSTREAM) {
- if (session->errors > session->ctx->max_errors) {
- session->error = SMTP_ERROR_LIMIT;
- session->state = SMTP_STATE_CRITICAL_ERROR;
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
- return FALSE;
- }
- destroy_session (session->s);
- return FALSE;
- }
- if (! smtp_write_socket (session)) {
+ case SMTP_STATE_RESOLVE_REVERSE:
+ case SMTP_STATE_RESOLVE_NORMAL:
+ case SMTP_STATE_DELAY:
+ session->error = make_smtp_error (session->pool,
+ 550,
+ "%s Improper use of SMTP command pipelining",
+ "5.5.0");
+ session->state = SMTP_STATE_ERROR;
+ break;
+ case SMTP_STATE_GREETING:
+ case SMTP_STATE_HELO:
+ case SMTP_STATE_FROM:
+ case SMTP_STATE_RCPT:
+ case SMTP_STATE_DATA:
+ read_smtp_command (session, in);
+ if (session->state != SMTP_STATE_WAIT_UPSTREAM) {
+ if (session->errors > session->ctx->max_errors) {
+ session->error = SMTP_ERROR_LIMIT;
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ session->error, 0, FALSE, TRUE)) {
return FALSE;
}
+ destroy_session (session->s);
+ return FALSE;
}
- break;
- case SMTP_STATE_AFTER_DATA:
- if (in->len == 0) {
- return TRUE;
- }
- if (in->len == 3 && memcmp (in->begin, DATA_END_TRAILER, in->len) == 0) {
- return process_smtp_data (session);
+ if (!smtp_write_socket (session)) {
+ return FALSE;
}
+ }
+ break;
+ case SMTP_STATE_AFTER_DATA:
+ if (in->len == 0) {
+ return TRUE;
+ }
+ if (in->len == 3 &&
+ memcmp (in->begin, DATA_END_TRAILER, in->len) == 0) {
+ return process_smtp_data (session);
+ }
- if (write (session->temp_fd, in->begin, in->len) != (ssize_t)in->len) {
- msg_err ("cannot write to temp file: %s", strerror (errno));
- session->error = SMTP_ERROR_FILE;
- session->state = SMTP_STATE_CRITICAL_ERROR;
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
- return FALSE;
- }
- destroy_session (session->s);
+ if (write (session->temp_fd, in->begin, in->len) != (ssize_t)in->len) {
+ msg_err ("cannot write to temp file: %s", strerror (errno));
+ session->error = SMTP_ERROR_FILE;
+ session->state = SMTP_STATE_CRITICAL_ERROR;
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
return FALSE;
}
- break;
- case SMTP_STATE_WAIT_UPSTREAM:
- rspamd_dispatcher_pause (session->dispatcher);
- break;
- default:
- session->error = make_smtp_error (session->pool, 550, "%s Internal error", "5.5.0");
- session->state = SMTP_STATE_ERROR;
- break;
+ destroy_session (session->s);
+ return FALSE;
+ }
+ break;
+ case SMTP_STATE_WAIT_UPSTREAM:
+ rspamd_dispatcher_pause (session->dispatcher);
+ break;
+ default:
+ session->error = make_smtp_error (session->pool,
+ 550,
+ "%s Internal error",
+ "5.5.0");
+ session->state = SMTP_STATE_ERROR;
+ break;
}
if (session->state == SMTP_STATE_QUIT) {
/*
* Callback for socket writing
*/
-static gboolean
+static gboolean
smtp_write_socket (void *arg)
{
- struct smtp_session *session = arg;
+ struct smtp_session *session = arg;
if (session->state == SMTP_STATE_CRITICAL_ERROR) {
if (session->error != NULL) {
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
return FALSE;
}
}
}
else {
if (session->error != NULL) {
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ session->error, 0, FALSE, TRUE)) {
return FALSE;
}
}
}
else {
if (session->error != NULL) {
- if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher, session->error,
+ 0, FALSE, TRUE)) {
return FALSE;
}
}
}
-
+
return TRUE;
}
static void
smtp_err_socket (GError * err, void *arg)
{
- struct smtp_session *session = arg;
+ struct smtp_session *session = arg;
msg_info ("abnormally closing connection, error: %s", err->message);
/* Free buffers */
write_smtp_greeting (struct smtp_session *session)
{
if (session->ctx->smtp_banner) {
- if (! rspamd_dispatcher_write (session->dispatcher, session->ctx->smtp_banner, 0, FALSE, TRUE)) {
+ if (!rspamd_dispatcher_write (session->dispatcher,
+ session->ctx->smtp_banner, 0, FALSE, TRUE)) {
return FALSE;
}
}
static void
smtp_delay_handler (gint fd, short what, void *arg)
{
- struct smtp_session *session = arg;
-
- remove_normal_event (session->s, (event_finalizer_t)event_del, session->delay_timer);
+ struct smtp_session *session = arg;
+
+ remove_normal_event (session->s,
+ (event_finalizer_t)event_del,
+ session->delay_timer);
if (session->state == SMTP_STATE_DELAY) {
session->state = SMTP_STATE_GREETING;
write_smtp_greeting (session);
static void
smtp_make_delay (struct smtp_session *session)
{
- struct event *tev;
- struct timeval *tv;
- gint32 jitter;
+ struct event *tev;
+ struct timeval *tv;
+ gint32 jitter;
if (session->ctx->smtp_delay != 0 && session->state == SMTP_STATE_DELAY) {
tev = rspamd_mempool_alloc (session->pool, sizeof (struct event));
evtimer_set (tev, smtp_delay_handler, session);
evtimer_add (tev, tv);
- register_async_event (session->s, (event_finalizer_t)event_del, tev, g_quark_from_static_string ("smtp proxy"));
+ register_async_event (session->s,
+ (event_finalizer_t)event_del,
+ tev,
+ g_quark_from_static_string ("smtp proxy"));
session->delay_timer = tev;
}
else if (session->state == SMTP_STATE_DELAY) {
static void
smtp_dns_cb (struct rspamd_dns_reply *reply, void *arg)
{
- struct smtp_session *session = arg;
- gint res = 0;
- union rspamd_reply_element *elt;
- GList *cur;
+ struct smtp_session *session = arg;
+ gint res = 0;
+ union rspamd_reply_element *elt;
+ GList *cur;
switch (session->state) {
- case SMTP_STATE_RESOLVE_REVERSE:
- /* Parse reverse reply and start resolve of this ip */
- if (reply->code != RDNS_RC_NOERROR) {
- rspamd_conditional_debug(rspamd_main->logger, session->client_addr.s_addr, __FUNCTION__,
- "DNS error: %s", dns_strerror (reply->code));
-
- if (reply->code == RDNS_RC_NXDOMAIN) {
- session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_UNAVAILABLE);
- }
- else {
- session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_TEMPFAIL);
- }
- session->state = SMTP_STATE_DELAY;
- smtp_make_delay (session);
+ case SMTP_STATE_RESOLVE_REVERSE:
+ /* Parse reverse reply and start resolve of this ip */
+ if (reply->code != RDNS_RC_NOERROR) {
+ rspamd_conditional_debug (rspamd_main->logger,
+ session->client_addr.s_addr,
+ __FUNCTION__,
+ "DNS error: %s",
+ dns_strerror (reply->code));
+
+ if (reply->code == RDNS_RC_NXDOMAIN) {
+ session->hostname = rspamd_mempool_strdup (session->pool,
+ XCLIENT_HOST_UNAVAILABLE);
}
else {
- if (reply->elements) {
- elt = reply->elements->data;
- session->hostname = rspamd_mempool_strdup (session->pool, elt->ptr.name);
- session->state = SMTP_STATE_RESOLVE_NORMAL;
- make_dns_request (session->resolver, session->s, session->pool,
- smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
-
- }
+ session->hostname = rspamd_mempool_strdup (session->pool,
+ XCLIENT_HOST_TEMPFAIL);
}
- break;
- case SMTP_STATE_RESOLVE_NORMAL:
- if (reply->code != RDNS_RC_NOERROR) {
- rspamd_conditional_debug(rspamd_main->logger, session->client_addr.s_addr, __FUNCTION__,
- "DNS error: %s", dns_strerror (reply->code));
+ session->state = SMTP_STATE_DELAY;
+ smtp_make_delay (session);
+ }
+ else {
+ if (reply->elements) {
+ elt = reply->elements->data;
+ session->hostname = rspamd_mempool_strdup (session->pool,
+ elt->ptr.name);
+ session->state = SMTP_STATE_RESOLVE_NORMAL;
+ make_dns_request (session->resolver, session->s, session->pool,
+ smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
- if (reply->code == RDNS_RC_NXDOMAIN) {
- session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_UNAVAILABLE);
- }
- else {
- session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_TEMPFAIL);
- }
- session->state = SMTP_STATE_DELAY;
- smtp_make_delay (session);
+ }
+ }
+ break;
+ case SMTP_STATE_RESOLVE_NORMAL:
+ if (reply->code != RDNS_RC_NOERROR) {
+ rspamd_conditional_debug (rspamd_main->logger,
+ session->client_addr.s_addr,
+ __FUNCTION__,
+ "DNS error: %s",
+ dns_strerror (reply->code));
+
+ if (reply->code == RDNS_RC_NXDOMAIN) {
+ session->hostname = rspamd_mempool_strdup (session->pool,
+ XCLIENT_HOST_UNAVAILABLE);
}
else {
- res = 0;
- cur = reply->elements;
- while (cur) {
- elt = cur->data;
- if (memcmp (&session->client_addr, &elt->a.addr[0], sizeof (struct in_addr)) == 0) {
- res = 1;
- session->resolved = TRUE;
- break;
- }
- cur = g_list_next (cur);
+ session->hostname = rspamd_mempool_strdup (session->pool,
+ XCLIENT_HOST_TEMPFAIL);
+ }
+ session->state = SMTP_STATE_DELAY;
+ smtp_make_delay (session);
+ }
+ else {
+ res = 0;
+ cur = reply->elements;
+ while (cur) {
+ elt = cur->data;
+ if (memcmp (&session->client_addr, &elt->a.addr[0],
+ sizeof (struct in_addr)) == 0) {
+ res = 1;
+ session->resolved = TRUE;
+ break;
}
+ cur = g_list_next (cur);
+ }
- if (res == 0) {
- msg_info ("cannot find address for hostname: %s, ip: %s", session->hostname, inet_ntoa (session->client_addr));
- session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_UNAVAILABLE);
- }
- session->state = SMTP_STATE_DELAY;
- smtp_make_delay (session);
+ if (res == 0) {
+ msg_info ("cannot find address for hostname: %s, ip: %s",
+ session->hostname,
+ inet_ntoa (session->client_addr));
+ session->hostname = rspamd_mempool_strdup (session->pool,
+ XCLIENT_HOST_UNAVAILABLE);
}
- break;
- case SMTP_STATE_ERROR:
- session->state = SMTP_STATE_WRITE_ERROR;
- smtp_write_socket (session);
- break;
- default:
- /*
- * This callback is called on unknown state, usually this indicates
- * an error (invalid pipelining)
- */
- break;
+ session->state = SMTP_STATE_DELAY;
+ smtp_make_delay (session);
+ }
+ break;
+ case SMTP_STATE_ERROR:
+ session->state = SMTP_STATE_WRITE_ERROR;
+ smtp_write_socket (session);
+ break;
+ default:
+ /*
+ * This callback is called on unknown state, usually this indicates
+ * an error (invalid pipelining)
+ */
+ break;
}
}
static void
accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- union sa_union su;
- struct smtp_session *session;
- struct smtp_worker_ctx *ctx;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ union sa_union su;
+ struct smtp_session *session;
+ struct smtp_worker_ctx *ctx;
- socklen_t addrlen = sizeof (su.ss);
- gint nfd;
+ socklen_t addrlen = sizeof (su.ss);
+ gint nfd;
- if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
+ if ((nfd =
+ accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
session->client_addr.s_addr = INADDR_NONE;
}
else if (su.ss.ss_family == AF_INET) {
- msg_info ("accepted connection from %s port %d", inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
- memcpy (&session->client_addr, &su.s4.sin_addr, sizeof (struct in_addr));
+ msg_info ("accepted connection from %s port %d",
+ inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
+ memcpy (&session->client_addr, &su.s4.sin_addr,
+ sizeof (struct in_addr));
}
session->sock = nfd;
/* Resolve client's addr */
/* Set up async session */
- session->s = new_async_session (session->pool, NULL, NULL, free_smtp_session, session);
+ session->s = new_async_session (session->pool,
+ NULL,
+ NULL,
+ free_smtp_session,
+ session);
session->state = SMTP_STATE_RESOLVE_REVERSE;
- if (! make_dns_request (session->resolver, session->s, session->pool,
- smtp_dns_cb, session, RDNS_REQUEST_PTR, &session->client_addr)) {
+ if (!make_dns_request (session->resolver, session->s, session->pool,
+ smtp_dns_cb, session, RDNS_REQUEST_PTR, &session->client_addr)) {
msg_err ("cannot resolve %s", inet_ntoa (session->client_addr));
g_free (session);
close (nfd);
return;
}
else {
- session->dispatcher = rspamd_create_dispatcher (session->ev_base, nfd, BUFFER_LINE,
- smtp_read_socket, smtp_write_socket, smtp_err_socket, &session->ctx->smtp_timeout, session);
+ session->dispatcher = rspamd_create_dispatcher (session->ev_base,
+ nfd,
+ BUFFER_LINE,
+ smtp_read_socket,
+ smtp_write_socket,
+ smtp_err_socket,
+ &session->ctx->smtp_timeout,
+ session);
session->dispatcher->peer_addr = session->client_addr.s_addr;
}
}
static void
parse_smtp_banner (struct smtp_worker_ctx *ctx, const gchar *line)
{
- gint hostmax, banner_len = sizeof ("220 ") - 1;
- gchar *p, *t, *hostbuf = NULL;
- gboolean has_crlf = FALSE;
+ gint hostmax, banner_len = sizeof ("220 ") - 1;
+ gchar *p, *t, *hostbuf = NULL;
+ gboolean has_crlf = FALSE;
p = (gchar *)line;
while (*p) {
if (*p == '%') {
- p ++;
+ p++;
switch (*p) {
- case 'n':
- /* Assume %n as CRLF */
- banner_len += sizeof (CRLF) - 1 + sizeof ("220 -") - 1;
- has_crlf = TRUE;
- break;
- case 'h':
- hostmax = sysconf (_SC_HOST_NAME_MAX) + 1;
- hostbuf = alloca (hostmax);
- gethostname (hostbuf, hostmax);
- hostbuf[hostmax - 1] = '\0';
- banner_len += strlen (hostbuf);
- break;
- case '%':
- banner_len += 1;
- break;
- default:
- banner_len += 2;
- break;
+ case 'n':
+ /* Assume %n as CRLF */
+ banner_len += sizeof (CRLF) - 1 + sizeof ("220 -") - 1;
+ has_crlf = TRUE;
+ break;
+ case 'h':
+ hostmax = sysconf (_SC_HOST_NAME_MAX) + 1;
+ hostbuf = alloca (hostmax);
+ gethostname (hostbuf, hostmax);
+ hostbuf[hostmax - 1] = '\0';
+ banner_len += strlen (hostbuf);
+ break;
+ case '%':
+ banner_len += 1;
+ break;
+ default:
+ banner_len += 2;
+ break;
}
}
else {
- banner_len ++;
+ banner_len++;
}
- p ++;
+ p++;
}
-
+
if (has_crlf) {
banner_len += sizeof (CRLF "220 " CRLF);
}
while (*p) {
if (*p == '%') {
- p ++;
+ p++;
switch (*p) {
- case 'n':
- /* Assume %n as CRLF */
- *t++ = CR; *t++ = LF;
- t = g_stpcpy (t, "220-");
- p ++;
- break;
- case 'h':
- t = g_stpcpy (t, hostbuf);
- p ++;
- break;
- case '%':
- *t++ = '%';
- p ++;
- break;
- default:
- /* Copy all %<gchar> to dest */
- *t++ = *(p - 1); *t++ = *p;
- break;
+ case 'n':
+ /* Assume %n as CRLF */
+ *t++ = CR; *t++ = LF;
+ t = g_stpcpy (t, "220-");
+ p++;
+ break;
+ case 'h':
+ t = g_stpcpy (t, hostbuf);
+ p++;
+ break;
+ case '%':
+ *t++ = '%';
+ p++;
+ break;
+ default:
+ /* Copy all %<gchar> to dest */
+ *t++ = *(p - 1); *t++ = *p;
+ break;
}
}
else {
- *t ++ = *p ++;
+ *t++ = *p++;
}
}
if (has_crlf) {
static void
make_capabilities (struct smtp_worker_ctx *ctx, const gchar *line)
{
- gchar **strv, *p, *result, *hostbuf;
- guint32 num, i, len, hostmax;
+ gchar **strv, *p, *result, *hostbuf;
+ guint32 num, i, len, hostmax;
strv = g_strsplit_set (line, ",;", -1);
num = g_strv_length (strv);
-
+
hostmax = sysconf (_SC_HOST_NAME_MAX) + 1;
hostbuf = alloca (hostmax);
gethostname (hostbuf, hostmax);
len = sizeof ("250-") + strlen (hostbuf) + sizeof (CRLF) - 1;
- for (i = 0; i < num; i ++) {
+ for (i = 0; i < num; i++) {
p = strv[i];
len += sizeof ("250-") + sizeof (CRLF) + strlen (p) - 2;
}
result = rspamd_mempool_alloc (ctx->pool, len);
ctx->smtp_capabilities = result;
-
+
p = result;
if (num == 0) {
p += rspamd_snprintf (p, len - (p - result), "250 %s" CRLF, hostbuf);
}
else {
p += rspamd_snprintf (p, len - (p - result), "250-%s" CRLF, hostbuf);
- for (i = 0; i < num; i ++) {
+ for (i = 0; i < num; i++) {
if (i != num - 1) {
- p += rspamd_snprintf (p, len - (p - result), "250-%s" CRLF, strv[i]);
+ p += rspamd_snprintf (p,
+ len - (p - result),
+ "250-%s" CRLF,
+ strv[i]);
}
else {
- p += rspamd_snprintf (p, len - (p - result), "250 %s" CRLF, strv[i]);
+ p += rspamd_snprintf (p,
+ len - (p - result),
+ "250 %s" CRLF,
+ strv[i]);
}
}
}
gpointer
init_smtp (struct rspamd_config *cfg)
{
- struct smtp_worker_ctx *ctx;
- GQuark type;
+ struct smtp_worker_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("smtp");
ctx = g_malloc0 (sizeof (struct smtp_worker_ctx));
ctx->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
-
+
/* Set default values */
ctx->smtp_timeout_raw = 300000;
ctx->smtp_delay = 0;
ctx->reject_message = DEFAULT_REJECT_MESSAGE;
rspamd_rcl_register_worker_option (cfg, type, "upstreams",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, upstreams_str), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx, upstreams_str), 0);
rspamd_rcl_register_worker_option (cfg, type, "banner",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_banner_str), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_banner_str), 0);
rspamd_rcl_register_worker_option (cfg, type, "timeout",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx,
+ smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
rspamd_rcl_register_worker_option (cfg, type, "delay",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx,
+ smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
rspamd_rcl_register_worker_option (cfg, type, "jitter",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx,
+ delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
rspamd_rcl_register_worker_option (cfg, type, "capabilities",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_capabilities_str), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_capabilities_str), 0);
rspamd_rcl_register_worker_option (cfg, type, "xclient",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, use_xclient), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx, use_xclient), 0);
rspamd_rcl_register_worker_option (cfg, type, "reject_message",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, reject_message), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx, reject_message), 0);
rspamd_rcl_register_worker_option (cfg, type, "max_errors",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, max_errors), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx,
+ max_errors), RSPAMD_CL_FLAG_INT_32);
rspamd_rcl_register_worker_option (cfg, type, "max_size",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct smtp_worker_ctx, max_size), RSPAMD_CL_FLAG_INT_SIZE);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct smtp_worker_ctx,
+ max_size), RSPAMD_CL_FLAG_INT_SIZE);
return ctx;
}
static gboolean
config_smtp_worker (struct rspamd_worker *worker)
{
- struct smtp_worker_ctx *ctx = worker->ctx;
- gchar *value;
+ struct smtp_worker_ctx *ctx = worker->ctx;
+ gchar *value;
/* Init timeval */
msec_to_tv (ctx->smtp_timeout_raw, &ctx->smtp_timeout);
/* Init upstreams */
if ((value = ctx->upstreams_str) != NULL) {
- if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value, &ctx->upstream_num)) {
+ if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value,
+ &ctx->upstream_num)) {
return FALSE;
}
}
if ((value = ctx->smtp_capabilities_str) != NULL) {
make_capabilities (ctx, value);
}
-
+
return TRUE;
}
void
start_smtp (struct rspamd_worker *worker)
{
- struct smtp_worker_ctx *ctx = worker->ctx;
+ struct smtp_worker_ctx *ctx = worker->ctx;
ctx->ev_base = rspamd_prepare_worker (worker, "smtp_worker", accept_socket);
umask (S_IWGRP | S_IWOTH | S_IROTH | S_IRGRP);
event_base_loop (ctx->ev_base, 0);
-
+
close_log (rspamd_main->logger);
exit (EXIT_SUCCESS);
}
-void
-register_smtp_filter (struct smtp_worker_ctx *ctx, enum rspamd_smtp_stage stage, smtp_filter_t filter, gpointer filter_data)
+void
+register_smtp_filter (struct smtp_worker_ctx *ctx,
+ enum rspamd_smtp_stage stage,
+ smtp_filter_t filter,
+ gpointer filter_data)
{
- struct smtp_filter *new;
+ struct smtp_filter *new;
new = rspamd_mempool_alloc (ctx->pool, sizeof (struct smtp_filter));
msg_err ("invalid smtp stage: %d", stage);
}
else {
- ctx->smtp_filters[stage] = g_list_prepend (ctx->smtp_filters[stage], new);
+ ctx->smtp_filters[stage] =
+ g_list_prepend (ctx->smtp_filters[stage], new);
}
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
#include "config.h"
#include "main.h"
-#include "upstream.h"
#include "smtp_utils.h"
+#include "upstream.h"
struct rspamd_dns_resolver;
struct smtp_upstream upstreams[MAX_SMTP_UPSTREAMS];
gsize upstream_num;
gchar *upstreams_str;
-
+
rspamd_mempool_t *pool;
gchar *smtp_banner;
gchar *smtp_banner_str;
GList *cur_rcpt;
guint errors;
-
+
struct rspamd_async_session *s;
rspamd_io_dispatcher_t *dispatcher;
rspamd_io_dispatcher_t *upstream_dispatcher;
struct event_base *ev_base;
};
-typedef gboolean (*smtp_filter_t)(struct smtp_session *session, gpointer filter_data);
+typedef gboolean (*smtp_filter_t)(struct smtp_session *session,
+ gpointer filter_data);
struct smtp_filter {
smtp_filter_t filter;
* Register new SMTP filter
* XXX: work is still in progress
*/
-void register_smtp_filter (struct smtp_worker_ctx *ctx, enum rspamd_smtp_stage stage, smtp_filter_t filter, gpointer filter_data);
+void register_smtp_filter (struct smtp_worker_ctx *ctx,
+ enum rspamd_smtp_stage stage,
+ smtp_filter_t filter,
+ gpointer filter_data);
#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include "cfg_file.h"
#include "config.h"
+#include "dns.h"
#include "main.h"
-#include "cfg_file.h"
-#include "util.h"
-#include "smtp_proto.h"
#include "map.h"
#include "message.h"
-#include "dns.h"
-#include "upstream.h"
#include "proxy.h"
+#include "smtp_proto.h"
+#include "upstream.h"
+#include "util.h"
/*
* SMTP proxy is a simple smtp proxy worker for dns resolving and
void start_smtp_proxy (struct rspamd_worker *worker);
worker_t smtp_proxy_worker = {
- "smtp_proxy", /* Name */
- init_smtp_proxy, /* Init function */
- start_smtp_proxy, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE, /* Killable */
- SOCK_STREAM /* TCP socket */
+ "smtp_proxy", /* Name */
+ init_smtp_proxy, /* Init function */
+ start_smtp_proxy, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE, /* Killable */
+ SOCK_STREAM /* TCP socket */
};
struct smtp_proxy_ctx {
static void
free_smtp_proxy_session (gpointer arg)
{
- struct smtp_proxy_session *session = arg;
+ struct smtp_proxy_session *session = arg;
static const char fatal_smtp_error[] = "521 5.2.1 Internal error" CRLF;
if (session) {
g_string_free (session->upstream_greeting, TRUE);
}
- if (session->state != SMTP_PROXY_STATE_PROXY && session->state != SMTP_PROXY_STATE_REJECT &&
- session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
+ if (session->state != SMTP_PROXY_STATE_PROXY && session->state !=
+ SMTP_PROXY_STATE_REJECT &&
+ session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
/* Send 521 fatal error */
- if (write (session->sock, fatal_smtp_error, sizeof (fatal_smtp_error)) == -1) {
+ if (write (session->sock, fatal_smtp_error,
+ sizeof (fatal_smtp_error)) == -1) {
msg_err ("write error to client failed: %s", strerror (errno));
}
}
- else if ((session->state == SMTP_PROXY_STATE_REJECT || session->state == SMTP_PROXY_STATE_REJECT_EMULATE) &&
- session->from && session->rcpt && session->dnsbl_applied) {
- msg_info ("reject by %s mail from <%s> to <%s>, ip: %s", session->dnsbl_applied,
- session->from, session->rcpt, inet_ntoa (session->client_addr));
+ else if ((session->state == SMTP_PROXY_STATE_REJECT || session->state ==
+ SMTP_PROXY_STATE_REJECT_EMULATE) &&
+ session->from && session->rcpt && session->dnsbl_applied) {
+ msg_info ("reject by %s mail from <%s> to <%s>, ip: %s",
+ session->dnsbl_applied,
+ session->from,
+ session->rcpt,
+ inet_ntoa (session->client_addr));
}
close (session->sock);
static void
smtp_proxy_err_proxy (GError * err, void *arg)
{
- struct smtp_proxy_session *session = arg;
+ struct smtp_proxy_session *session = arg;
if (err) {
g_error_free (err);
static gint
check_valid_smtp_greeting (GString *s)
{
- gchar *p;
+ gchar *p;
p = s->str + s->len - 1;
if (s->len < 6 || (*p != '\n' || *(p - 1) != '\r')) {
return 0;
}
else if ((*p == '5' || *p == '4' || *p == '3') &&
- g_ascii_isdigit (p[1]) && g_ascii_isdigit (p[2]) && p[3] == ' ') {
+ g_ascii_isdigit (p[1]) && g_ascii_isdigit (p[2]) && p[3] == ' ') {
return -1;
}
- p --;
+ p--;
}
return 1;
static void
smtp_proxy_greeting_handler (gint fd, short what, void *arg)
{
- struct smtp_proxy_session *session = arg;
- gint r;
- gchar read_buf[BUFSIZ];
+ struct smtp_proxy_session *session = arg;
+ gint r;
+ gchar read_buf[BUFSIZ];
if (what == EV_READ) {
if (session->state == SMTP_PROXY_STATE_GREETING) {
if (r == 1) {
/* Send xclient */
if (session->ctx->use_xclient) {
- r = rspamd_snprintf (read_buf, sizeof (read_buf), "XCLIENT NAME=%s ADDR=%s" CRLF,
- session->hostname, inet_ntoa (session->client_addr));
+ r = rspamd_snprintf (read_buf,
+ sizeof (read_buf),
+ "XCLIENT NAME=%s ADDR=%s" CRLF,
+ session->hostname,
+ inet_ntoa (session->client_addr));
r = write (session->upstream_sock, read_buf, r);
if (r < 0 && errno == EAGAIN) {
/* Add write event */
event_del (&session->upstream_ev);
- event_set (&session->upstream_ev, session->upstream_sock,
- EV_WRITE, smtp_proxy_greeting_handler, session);
- event_base_set (session->ev_base, &session->upstream_ev);
+ event_set (&session->upstream_ev,
+ session->upstream_sock,
+ EV_WRITE,
+ smtp_proxy_greeting_handler,
+ session);
+ event_base_set (session->ev_base,
+ &session->upstream_ev);
event_add (&session->upstream_ev, NULL);
}
else if (r > 0) {
session->state = SMTP_PROXY_STATE_XCLIENT;
}
else {
- msg_info ("connection with %s got write error: %s", inet_ntoa (session->client_addr), strerror (errno));
+ msg_info ("connection with %s got write error: %s",
+ inet_ntoa (session->client_addr),
+ strerror (errno));
destroy_session (session->s);
}
}
else {
event_del (&session->upstream_ev);
/* Start direct proxy */
- r = write (session->sock, session->upstream_greeting->str, session->upstream_greeting->len);
+ r = write (session->sock,
+ session->upstream_greeting->str,
+ session->upstream_greeting->len);
/* TODO: handle client's error here */
if (r > 0) {
- session->proxy = rspamd_create_proxy (session->sock, session->upstream_sock, session->pool,
- session->ev_base, session->ctx->proxy_buf_len,
- &session->ctx->smtp_timeout, smtp_proxy_err_proxy, session);
+ session->proxy = rspamd_create_proxy (session->sock,
+ session->upstream_sock,
+ session->pool,
+ session->ev_base,
+ session->ctx->proxy_buf_len,
+ &session->ctx->smtp_timeout,
+ smtp_proxy_err_proxy,
+ session);
session->state = SMTP_PROXY_STATE_PROXY;
}
else {
- msg_info ("connection with %s got write error: %s", inet_ntoa (session->client_addr), strerror (errno));
+ msg_info ("connection with %s got write error: %s",
+ inet_ntoa (session->client_addr),
+ strerror (errno));
destroy_session (session->s);
}
}
}
else if (r == -1) {
/* Proxy sent 500 error */
- msg_info ("connection with %s got smtp error for greeting", session->upstream->name);
+ msg_info ("connection with %s got smtp error for greeting",
+ session->upstream->name);
destroy_session (session->s);
}
}
else {
- msg_info ("connection with %s got read error: %s", session->upstream->name, strerror (errno));
+ msg_info ("connection with %s got read error: %s",
+ session->upstream->name,
+ strerror (errno));
destroy_session (session->s);
}
}
if (r == 1) {
event_del (&session->upstream_ev);
/* Start direct proxy */
- r = write (session->sock, session->upstream_greeting->str, session->upstream_greeting->len);
+ r = write (session->sock,
+ session->upstream_greeting->str,
+ session->upstream_greeting->len);
/* TODO: handle client's error here */
if (r > 0) {
- session->proxy = rspamd_create_proxy (session->sock, session->upstream_sock, session->pool,
- session->ev_base, session->ctx->proxy_buf_len,
- &session->ctx->smtp_timeout, smtp_proxy_err_proxy, session);
+ session->proxy = rspamd_create_proxy (session->sock,
+ session->upstream_sock,
+ session->pool,
+ session->ev_base,
+ session->ctx->proxy_buf_len,
+ &session->ctx->smtp_timeout,
+ smtp_proxy_err_proxy,
+ session);
session->state = SMTP_PROXY_STATE_PROXY;
}
else {
- msg_info ("connection with %s got write error: %s", inet_ntoa (session->client_addr), strerror (errno));
+ msg_info ("connection with %s got write error: %s",
+ inet_ntoa (session->client_addr),
+ strerror (errno));
destroy_session (session->s);
}
}
else if (r == -1) {
/* Proxy sent 500 error */
- msg_info ("connection with %s got smtp error for xclient", session->upstream->name);
+ msg_info ("connection with %s got smtp error for xclient",
+ session->upstream->name);
destroy_session (session->s);
}
}
}
else {
- msg_info ("connection with %s got read event at improper state: %d", session->upstream->name, session->state);
+ msg_info ("connection with %s got read event at improper state: %d",
+ session->upstream->name,
+ session->state);
destroy_session (session->s);
}
}
else if (what == EV_WRITE) {
if (session->state == SMTP_PROXY_STATE_GREETING) {
/* Send xclient again */
- r = rspamd_snprintf (read_buf, sizeof (read_buf), "XCLIENT NAME=%s ADDR=%s" CRLF,
- session->hostname, inet_ntoa (session->client_addr));
+ r = rspamd_snprintf (read_buf,
+ sizeof (read_buf),
+ "XCLIENT NAME=%s ADDR=%s" CRLF,
+ session->hostname,
+ inet_ntoa (session->client_addr));
r = write (session->upstream_sock, read_buf, r);
if (r < 0 && errno == EAGAIN) {
/* Add write event */
event_del (&session->upstream_ev);
event_set (&session->upstream_ev, session->upstream_sock,
- EV_WRITE, smtp_proxy_greeting_handler, session);
+ EV_WRITE, smtp_proxy_greeting_handler, session);
event_base_set (session->ev_base, &session->upstream_ev);
event_add (&session->upstream_ev, NULL);
}
session->state = SMTP_PROXY_STATE_XCLIENT;
event_del (&session->upstream_ev);
event_set (&session->upstream_ev, session->upstream_sock,
- EV_READ | EV_PERSIST, smtp_proxy_greeting_handler, session);
+ EV_READ | EV_PERSIST, smtp_proxy_greeting_handler, session);
event_base_set (session->ev_base, &session->upstream_ev);
event_add (&session->upstream_ev, NULL);
}
else {
- msg_info ("connection with %s got write error: %s", session->upstream->name, strerror (errno));
+ msg_info ("connection with %s got write error: %s",
+ session->upstream->name,
+ strerror (errno));
destroy_session (session->s);
}
}
else {
- msg_info ("connection with %s got write event at improper state: %d", session->upstream->name, session->state);
+ msg_info (
+ "connection with %s got write event at improper state: %d",
+ session->upstream->name,
+ session->state);
destroy_session (session->s);
}
}
static gboolean
create_smtp_proxy_upstream_connection (struct smtp_proxy_session *session)
{
- struct smtp_upstream *selected;
+ struct smtp_upstream *selected;
/* Try to select upstream */
- selected = (struct smtp_upstream *)get_upstream_round_robin (session->ctx->upstreams,
- session->ctx->upstream_num, sizeof (struct smtp_upstream),
- time (NULL), DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
+ selected = (struct smtp_upstream *)get_upstream_round_robin (
+ session->ctx->upstreams,
+ session->ctx->upstream_num,
+ sizeof (struct smtp_upstream),
+ time (NULL),
+ DEFAULT_UPSTREAM_ERROR_TIME,
+ DEFAULT_UPSTREAM_DEAD_TIME,
+ DEFAULT_UPSTREAM_MAXERRORS);
if (selected == NULL) {
msg_err ("no upstreams suitable found");
return FALSE;
session->upstream = selected;
/* Now try to create socket */
- session->upstream_sock = make_universal_socket (selected->name, selected->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+ session->upstream_sock = make_universal_socket (selected->name,
+ selected->port,
+ SOCK_STREAM,
+ TRUE,
+ FALSE,
+ FALSE);
if (session->upstream_sock == -1) {
msg_err ("cannot make a connection to %s", selected->name);
upstream_fail (&selected->up, time (NULL));
/* First of all get upstream's greeting */
session->state = SMTP_PROXY_STATE_GREETING;
- event_set (&session->upstream_ev, session->upstream_sock, EV_READ | EV_PERSIST, smtp_proxy_greeting_handler, session);
+ event_set (&session->upstream_ev,
+ session->upstream_sock,
+ EV_READ | EV_PERSIST,
+ smtp_proxy_greeting_handler,
+ session);
event_base_set (session->ev_base, &session->upstream_ev);
event_add (&session->upstream_ev, &session->ctx->smtp_timeout);
static void
smtp_dnsbl_cb (struct rdns_reply *reply, void *arg)
{
- struct smtp_proxy_session *session = arg;
- const gchar *p;
- gint dots = 0;
- const struct rdns_request_name *req_name;
+ struct smtp_proxy_session *session = arg;
+ const gchar *p;
+ gint dots = 0;
+ const struct rdns_request_name *req_name;
- session->rbl_requests --;
+ session->rbl_requests--;
req_name = rdns_request_get_name (reply->request, NULL);
- msg_debug ("got reply for %s: %s", req_name[0].name, rdns_strerror (reply->code));
+ msg_debug ("got reply for %s: %s", req_name[0].name,
+ rdns_strerror (reply->code));
if (session->state != SMTP_PROXY_STATE_REJECT) {
p = req_name[0].name;
while (*p) {
if (*p == '.') {
- dots ++;
+ dots++;
}
if (dots == 4) {
session->dnsbl_applied = (gchar *)p + 1;
break;
}
- p ++;
+ p++;
}
session->state = SMTP_PROXY_STATE_REJECT;
}
else {
if (session->ctx->instant_reject) {
msg_info ("reject %s is denied by dnsbl: %s",
- inet_ntoa (session->client_addr), session->dnsbl_applied);
+ inet_ntoa (session->client_addr), session->dnsbl_applied);
if (!rspamd_dispatcher_write (session->dispatcher,
- make_smtp_error (session->pool, 521, "%s Client denied by %s", "5.2.1", session->dnsbl_applied),
- 0, FALSE, TRUE)) {
+ make_smtp_error (session->pool, 521,
+ "%s Client denied by %s", "5.2.1", session->dnsbl_applied),
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp error");
}
}
else {
/* Emulate fake smtp session */
- rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0);
+ rspamd_set_dispatcher_policy (session->dispatcher,
+ BUFFER_LINE,
+ 0);
if (!rspamd_dispatcher_write (session->dispatcher,
- make_smtp_error (session->pool, 220, "smtp ready"),
- 0, FALSE, TRUE)) {
+ make_smtp_error (session->pool, 220, "smtp ready"),
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp reply");
}
}
static void
make_rbl_requests (struct smtp_proxy_session *session)
{
- GList *cur;
- gchar *p, *dst;
- guint len;
+ GList *cur;
+ gchar *p, *dst;
+ guint len;
cur = session->ctx->rbls;
while (cur) {
/* Print ipv4 addr */
p = (gchar *)&session->client_addr.s_addr;
rspamd_snprintf (dst, len, "%ud.%ud.%ud.%ud.%s", (guint)p[3],
- (guint)p[2], (guint)p[1], (guint)p[0], cur->data);
+ (guint)p[2], (guint)p[1], (guint)p[0], cur->data);
if (make_dns_request (session->resolver, session->s, session->pool,
- smtp_dnsbl_cb, session, RDNS_REQUEST_A, dst)) {
- session->rbl_requests ++;
+ smtp_dnsbl_cb, session, RDNS_REQUEST_A, dst)) {
+ session->rbl_requests++;
msg_debug ("send request to %s", dst);
}
cur = g_list_next (cur);
if (session->rbl_requests == 0) {
/* Create proxy */
- if (! create_smtp_proxy_upstream_connection (session)) {
+ if (!create_smtp_proxy_upstream_connection (session)) {
rspamd_dispatcher_restore (session->dispatcher);
}
}
static void
smtp_delay_handler (gint fd, short what, void *arg)
{
- struct smtp_proxy_session *session = arg;
+ struct smtp_proxy_session *session = arg;
remove_normal_event (session->s, (event_finalizer_t) event_del,
- session->delay_timer);
+ session->delay_timer);
if (session->state == SMTP_PROXY_STATE_DELAY) {
/* TODO: Create upstream connection here */
if (session->ctx->rbls) {
/* TODO: Write error here */
session->state = SMTP_PROXY_STATE_REJECT;
if (!rspamd_dispatcher_write (session->dispatcher,
- make_smtp_error (session->pool, 521, "%s Improper use of SMTP command pipelining", "5.2.1"),
- 0, FALSE, TRUE)) {
+ make_smtp_error (session->pool, 521,
+ "%s Improper use of SMTP command pipelining", "5.2.1"),
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp error");
}
rspamd_dispatcher_restore (session->dispatcher);
static void
smtp_make_delay (struct smtp_proxy_session *session)
{
- struct event *tev;
- struct timeval *tv;
- gint32 jitter;
+ struct event *tev;
+ struct timeval *tv;
+ gint32 jitter;
- if (session->ctx->smtp_delay != 0 && session->state == SMTP_PROXY_STATE_DELAY) {
+ if (session->ctx->smtp_delay != 0 && session->state ==
+ SMTP_PROXY_STATE_DELAY) {
tev = rspamd_mempool_alloc (session->pool, sizeof(struct event));
tv = rspamd_mempool_alloc (session->pool, sizeof(struct timeval));
if (session->ctx->delay_jitter != 0) {
evtimer_set (tev, smtp_delay_handler, session);
evtimer_add (tev, tv);
register_async_event (session->s, (event_finalizer_t) event_del, tev,
- g_quark_from_static_string ("smtp proxy"));
+ g_quark_from_static_string ("smtp proxy"));
session->delay_timer = tev;
}
else if (session->state == SMTP_PROXY_STATE_DELAY) {
static void
smtp_dns_cb (struct rdns_reply *reply, void *arg)
{
- struct smtp_proxy_session *session = arg;
- gint res = 0;
- struct rdns_reply_entry *elt;
- GList *cur;
+ struct smtp_proxy_session *session = arg;
+ gint res = 0;
+ struct rdns_reply_entry *elt;
+ GList *cur;
switch (session->state)
{
/* Parse reverse reply and start resolve of this ip */
if (reply->code != RDNS_RC_NOERROR) {
rspamd_conditional_debug (rspamd_main->logger,
- NULL, __FUNCTION__, "DNS error: %s",
- rdns_strerror (reply->code));
+ NULL, __FUNCTION__, "DNS error: %s",
+ rdns_strerror (reply->code));
if (reply->code == RDNS_RC_NXDOMAIN) {
session->hostname = rspamd_mempool_strdup (session->pool,
elt->content.ptr.name);
session->state = SMTP_PROXY_STATE_RESOLVE_NORMAL;
make_dns_request (session->resolver, session->s, session->pool,
- smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
+ smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
}
}
case SMTP_PROXY_STATE_RESOLVE_NORMAL:
if (reply->code != RDNS_RC_NOERROR) {
rspamd_conditional_debug (rspamd_main->logger,
- NULL, __FUNCTION__, "DNS error: %s",
- rdns_strerror (reply->code));
+ NULL, __FUNCTION__, "DNS error: %s",
+ rdns_strerror (reply->code));
if (reply->code == RDNS_RC_NXDOMAIN) {
session->hostname = rspamd_mempool_strdup (session->pool,
}
else {
res = 0;
- LL_FOREACH (reply->entries, elt) {
+ LL_FOREACH (reply->entries, elt)
+ {
if (memcmp (&session->client_addr, &elt->content.a.addr,
- sizeof(struct in_addr)) == 0) {
+ sizeof(struct in_addr)) == 0) {
res = 1;
session->resolved = TRUE;
break;
}
if (res == 0) {
- msg_info(
- "cannot find address for hostname: %s, ip: %s", session->hostname,
- inet_ntoa (session->client_addr));
+ msg_info (
+ "cannot find address for hostname: %s, ip: %s",
+ session->hostname,
+ inet_ntoa (session->client_addr));
session->hostname = rspamd_mempool_strdup (session->pool,
XCLIENT_HOST_UNAVAILABLE);
}
static void
proxy_parse_smtp_input (f_str_t *line, struct smtp_proxy_session *session)
{
- gchar *p, *c, *end;
- gsize len;
+ gchar *p, *c, *end;
+ gsize len;
p = line->begin;
end = line->begin + line->len;
- if (line->len >= sizeof("rcpt to: ") - 1 && (*p == 'r' || *p == 'R') && session->rcpt == NULL) {
- if (g_ascii_strncasecmp (p, "rcpt to: ", sizeof ("rcpt to: ") - 1) == 0) {
+ if (line->len >= sizeof("rcpt to: ") - 1 &&
+ (*p == 'r' || *p == 'R') && session->rcpt == NULL) {
+ if (g_ascii_strncasecmp (p, "rcpt to: ",
+ sizeof ("rcpt to: ") - 1) == 0) {
p += sizeof ("rcpt to: ") - 1;
/* Skip spaces */
while ((g_ascii_isspace (*p) || *p == '<') && p < end) {
- p ++;
+ p++;
}
c = p;
while (!(g_ascii_isspace (*p) || *p == '>') && p < end) {
- p ++;
+ p++;
}
len = p - c;
session->rcpt = rspamd_mempool_alloc (session->pool, len + 1);
rspamd_strlcpy (session->rcpt, c, len + 1);
}
}
- else if (line->len >= sizeof("mail from: ") - 1 && (*p == 'm' || *p == 'M') && session->from == NULL) {
- if (g_ascii_strncasecmp (p, "mail from: ", sizeof ("mail from: ") - 1) == 0) {
+ else if (line->len >= sizeof("mail from: ") - 1 &&
+ (*p == 'm' || *p == 'M') && session->from == NULL) {
+ if (g_ascii_strncasecmp (p, "mail from: ", sizeof ("mail from: ") -
+ 1) == 0) {
p += sizeof ("mail from: ") - 1;
/* Skip spaces */
while ((g_ascii_isspace (*p) || *p == '<') && p < end) {
- p ++;
+ p++;
}
c = p;
while (!(g_ascii_isspace (*p) || *p == '>') && p < end) {
- p ++;
+ p++;
}
len = p - c;
session->from = rspamd_mempool_alloc (session->pool, len + 1);
/*
* Callback that is called when there is data to read in buffer
*/
-static gboolean
+static gboolean
smtp_proxy_read_socket (f_str_t * in, void *arg)
{
- struct smtp_proxy_session *session = arg;
- gchar *p;
+ struct smtp_proxy_session *session = arg;
+ gchar *p;
if (session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
/* This can be called only if client is using invalid pipelining */
session->state = SMTP_PROXY_STATE_REJECT;
if (!rspamd_dispatcher_write (session->dispatcher,
- make_smtp_error (session->pool, 521, "%s Improper use of SMTP command pipelining", "5.2.1"),
- 0, FALSE, TRUE)) {
+ make_smtp_error (session->pool, 521,
+ "%s Improper use of SMTP command pipelining", "5.2.1"),
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp error");
}
destroy_session (session->s);
else {
/* Try to extract data */
p = in->begin;
- if (in->len >= sizeof ("helo") - 1 && (*p == 'h' || *p == 'H' || *p == 'e' || *p == 'E')) {
+ if (in->len >= sizeof ("helo") - 1 &&
+ (*p == 'h' || *p == 'H' || *p == 'e' || *p == 'E')) {
return rspamd_dispatcher_write (session->dispatcher,
- "220 smtp ready" CRLF,
- 0, FALSE, TRUE);
+ "220 smtp ready" CRLF,
+ 0, FALSE, TRUE);
}
else if (in->len > 0) {
proxy_parse_smtp_input (in, session);
if (session->state == SMTP_PROXY_STATE_REJECT) {
/* Received QUIT command */
if (!rspamd_dispatcher_write (session->dispatcher,
- "221 2.0.0 Bye" CRLF,
- 0, FALSE, TRUE)) {
+ "221 2.0.0 Bye" CRLF,
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp error");
}
destroy_session (session->s);
return FALSE;
}
if (session->rcpt != NULL) {
- session->errors ++;
+ session->errors++;
if (session->errors > SMTP_MAXERRORS) {
if (!rspamd_dispatcher_write (session->dispatcher,
- "521 5.2.1 Maximum errors reached" CRLF,
- 0, FALSE, TRUE)) {
+ "521 5.2.1 Maximum errors reached" CRLF,
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp error");
}
destroy_session (session->s);
return FALSE;
}
return rspamd_dispatcher_write (session->dispatcher,
- make_smtp_error (session->pool, 521, "%s Client denied by %s", "5.2.1", session->dnsbl_applied),
- 0, FALSE, TRUE);
+ make_smtp_error (session->pool,
+ 521,
+ "%s Client denied by %s",
+ "5.2.1",
+ session->dnsbl_applied),
+ 0, FALSE, TRUE);
}
else {
return rspamd_dispatcher_write (session->dispatcher,
- "250 smtp ready" CRLF,
- 0, FALSE, TRUE);
+ "250 smtp ready" CRLF,
+ 0, FALSE, TRUE);
}
}
/*
* Actually called only if something goes wrong
*/
-static gboolean
+static gboolean
smtp_proxy_write_socket (void *arg)
{
- struct smtp_proxy_session *session = arg;
+ struct smtp_proxy_session *session = arg;
if (session->ctx->instant_reject) {
destroy_session (session->s);
static void
smtp_proxy_err_socket (GError * err, void *arg)
{
- struct smtp_proxy_session *session = arg;
+ struct smtp_proxy_session *session = arg;
if (err) {
if (err->code == ETIMEDOUT) {
/* Write smtp error */
if (!rspamd_dispatcher_write (session->dispatcher,
- "421 4.4.2 Error: timeout exceeded" CRLF,
- 0, FALSE, TRUE)) {
+ "421 4.4.2 Error: timeout exceeded" CRLF,
+ 0, FALSE, TRUE)) {
msg_err ("cannot write smtp error");
}
}
static void
accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- struct smtp_proxy_session *session;
- struct smtp_proxy_ctx *ctx;
- rspamd_inet_addr_t addr;
- gint nfd;
+ struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+ struct smtp_proxy_session *session;
+ struct smtp_proxy_ctx *ctx;
+ rspamd_inet_addr_t addr;
+ gint nfd;
ctx = worker->ctx;
if ((nfd =
- rspamd_accept_from_socket (fd, &addr)) == -1) {
+ rspamd_accept_from_socket (fd, &addr)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
}
msg_info ("accepted connection from %s port %d",
- rspamd_inet_address_to_string (&addr),
- rspamd_inet_address_get_port (&addr));
+ rspamd_inet_address_to_string (&addr),
+ rspamd_inet_address_get_port (&addr));
ctx = worker->ctx;
session = g_slice_alloc0 (sizeof (struct smtp_proxy_session));
session->resolver = ctx->resolver;
session->ev_base = ctx->ev_base;
session->upstream_sock = -1;
- session->ptr_str = rdns_generate_ptr_from_str (rspamd_inet_address_to_string (&addr));
+ session->ptr_str = rdns_generate_ptr_from_str (rspamd_inet_address_to_string (
+ &addr));
worker->srv->stat->connections_count++;
/* Resolve client's addr */
/* Set up async session */
- session->s = new_async_session (session->pool, NULL, NULL, free_smtp_proxy_session, session);
+ session->s = new_async_session (session->pool,
+ NULL,
+ NULL,
+ free_smtp_proxy_session,
+ session);
session->state = SMTP_PROXY_STATE_RESOLVE_REVERSE;
- if (! make_dns_request (session->resolver, session->s, session->pool,
- smtp_dns_cb, session, RDNS_REQUEST_PTR, session->ptr_str)) {
+ if (!make_dns_request (session->resolver, session->s, session->pool,
+ smtp_dns_cb, session, RDNS_REQUEST_PTR, session->ptr_str)) {
msg_err ("cannot resolve %s", inet_ntoa (session->client_addr));
g_slice_free1 (sizeof (struct smtp_proxy_session), session);
close (nfd);
return;
}
else {
- session->dispatcher = rspamd_create_dispatcher (session->ev_base, nfd, BUFFER_ANY,
- smtp_proxy_read_socket, smtp_proxy_write_socket, smtp_proxy_err_socket,
- &session->ctx->smtp_timeout, session);
+ session->dispatcher = rspamd_create_dispatcher (session->ev_base,
+ nfd,
+ BUFFER_ANY,
+ smtp_proxy_read_socket,
+ smtp_proxy_write_socket,
+ smtp_proxy_err_socket,
+ &session->ctx->smtp_timeout,
+ session);
session->dispatcher->peer_addr = session->client_addr.s_addr;
}
}
gpointer
init_smtp_proxy (struct rspamd_config *cfg)
{
- struct smtp_proxy_ctx *ctx;
- GQuark type;
+ struct smtp_proxy_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("smtp_proxy");
ctx->instant_reject = TRUE;
rspamd_rcl_register_worker_option (cfg, type, "upstreams",
- rspamd_rcl_parse_struct_string, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, upstreams_str), 0);
+ rspamd_rcl_parse_struct_string, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx, upstreams_str), 0);
rspamd_rcl_register_worker_option (cfg, type, "timeout",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx,
+ smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
rspamd_rcl_register_worker_option (cfg, type, "delay",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx,
+ smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
rspamd_rcl_register_worker_option (cfg, type, "jitter",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx,
+ delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
rspamd_rcl_register_worker_option (cfg, type, "xclient",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, use_xclient), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx, use_xclient), 0);
rspamd_rcl_register_worker_option (cfg, type, "instant_reject",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, instant_reject), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx, instant_reject), 0);
rspamd_rcl_register_worker_option (cfg, type, "proxy_buffer",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, proxy_buf_len), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx,
+ proxy_buf_len), RSPAMD_CL_FLAG_INT_32);
rspamd_rcl_register_worker_option (cfg, type, "dnsbl",
- rspamd_rcl_parse_struct_string_list, ctx,
- G_STRUCT_OFFSET (struct smtp_proxy_ctx, rbls), 0);
+ rspamd_rcl_parse_struct_string_list, ctx,
+ G_STRUCT_OFFSET (struct smtp_proxy_ctx, rbls), 0);
return ctx;
}
static gboolean
config_smtp_proxy_worker (struct rspamd_worker *worker)
{
- struct smtp_proxy_ctx *ctx = worker->ctx;
- gchar *value;
+ struct smtp_proxy_ctx *ctx = worker->ctx;
+ gchar *value;
/* Init timeval */
msec_to_tv (ctx->smtp_timeout_raw, &ctx->smtp_timeout);
/* Init upstreams */
if ((value = ctx->upstreams_str) != NULL) {
- if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value, &ctx->upstream_num)) {
+ if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value,
+ &ctx->upstream_num)) {
return FALSE;
}
}
void
start_smtp_proxy (struct rspamd_worker *worker)
{
- struct smtp_proxy_ctx *ctx = worker->ctx;
+ struct smtp_proxy_ctx *ctx = worker->ctx;
ctx->ev_base = rspamd_prepare_worker (worker, "smtp_proxy", accept_socket);
}
/* DNS resolver */
- ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
+ ctx->resolver = dns_resolver_init (worker->srv->logger,
+ ctx->ev_base,
+ worker->srv->cfg);
/* Set umask */
umask (S_IWGRP | S_IWOTH | S_IROTH | S_IRGRP);
* OSB tokenizer
*/
-#include <sys/types.h>
#include "tokenizers.h"
+#include <sys/types.h>
/* Minimum length of token */
#define MIN_LEN 4
-extern const int primes[];
+extern const int primes[];
int
-osb_tokenize_text (struct tokenizer *tokenizer, rspamd_mempool_t * pool, f_str_t * input, GTree ** tree,
- gboolean save_token, gboolean is_utf, GList *exceptions)
+osb_tokenize_text (struct tokenizer *tokenizer,
+ rspamd_mempool_t * pool,
+ f_str_t * input,
+ GTree ** tree,
+ gboolean save_token,
+ gboolean is_utf,
+ GList *exceptions)
{
- token_node_t *new = NULL;
- f_str_t token = { NULL, 0, 0 };
- guint32 hashpipe[FEATURE_WINDOW_SIZE], h1, h2;
- gint i, l, processed = 0;
- gchar *res;
+ token_node_t *new = NULL;
+ f_str_t token = { NULL, 0, 0 };
+ guint32 hashpipe[FEATURE_WINDOW_SIZE], h1, h2;
+ gint i, l, processed = 0;
+ gchar *res;
if (*tree == NULL) {
*tree = g_tree_new (token_node_compare_func);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_tree_destroy,
+ *tree);
}
memset (hashpipe, 0xfe, FEATURE_WINDOW_SIZE * sizeof (hashpipe[0]));
- while ((res = tokenizer->get_next_word (input, &token, &exceptions)) != NULL) {
+ while ((res =
+ tokenizer->get_next_word (input, &token, &exceptions)) != NULL) {
/* Skip small words */
if (is_utf) {
l = g_utf8_strlen (token.begin, token.len);
if (processed < FEATURE_WINDOW_SIZE) {
/* Just fill a hashpipe */
hashpipe[FEATURE_WINDOW_SIZE - ++processed] =
- fstrhash_lowercase (&token, is_utf);
+ fstrhash_lowercase (&token, is_utf);
}
else {
/* Shift hashpipe */
hashpipe[i] = hashpipe[i - 1];
}
hashpipe[0] = fstrhash_lowercase (&token, is_utf);
- processed ++;
+ processed++;
for (i = 1; i < FEATURE_WINDOW_SIZE; i++) {
h1 = hashpipe[0] * primes[0] + hashpipe[i] * primes[i << 1];
- h2 = hashpipe[0] * primes[1] + hashpipe[i] * primes[(i << 1) - 1];
+ h2 = hashpipe[0] * primes[1] + hashpipe[i] *
+ primes[(i << 1) - 1];
new = rspamd_mempool_alloc0 (pool, sizeof (token_node_t));
new->h1 = h1;
new->h2 = h2;
if (save_token) {
- new->extra = (uintptr_t)rspamd_mempool_fstrdup (pool, &token);
+ new->extra =
+ (uintptr_t)rspamd_mempool_fstrdup (pool, &token);
}
if (g_tree_lookup (*tree, new) == NULL) {
* Common tokenization functions
*/
-#include <sys/types.h>
#include "main.h"
#include "tokenizers.h"
+#include <sys/types.h>
-struct tokenizer tokenizers[] = {
+struct tokenizer tokenizers[] = {
{"osb-text", osb_tokenize_text, get_next_word},
};
-const int primes[] = {
+const int primes[] = {
1, 7,
3, 13,
5, 29,
};
const gchar t_delimiters[255] = {
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 1, 0, 1, 1, 1, 1, 1, 0,
- 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
- 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+ 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0
};
-struct tokenizer *
+struct tokenizer *
get_tokenizer (const char *name)
{
- guint i;
+ guint i;
for (i = 0; i < sizeof (tokenizers) / sizeof (tokenizers[0]); i++) {
if (strcmp (tokenizers[i].name, name) == 0) {
int
token_node_compare_func (gconstpointer a, gconstpointer b)
{
- const token_node_t *aa = a, *bb = b;
+ const token_node_t *aa = a, *bb = b;
if (aa->h1 == bb->h1) {
return aa->h2 - bb->h2;
gchar *
get_next_word (f_str_t * buf, f_str_t * token, GList **exceptions)
{
- gsize remain, pos;
- guchar *p;
- struct process_exception *ex = NULL;
+ gsize remain, pos;
+ guchar *p;
+ struct process_exception *ex = NULL;
if (buf == NULL) {
return NULL;
token->len++;
pos++;
remain--;
- p ++;
+ p++;
}
if (remain == 0) {
/* Struct to access gmime headers */
struct raw_header {
- struct raw_header *next;
- char *name;
- char *value;
+ struct raw_header *next;
+ char *name;
+ char *value;
};
typedef struct _GMimeHeader {
- GHashTable *hash;
- GHashTable *writers;
- struct raw_header *headers;
+ GHashTable *hash;
+ GHashTable *writers;
+ struct raw_header *headers;
} local_GMimeHeader;
int
-tokenize_headers (rspamd_mempool_t * pool, struct rspamd_task *task, GTree ** tree)
+tokenize_headers (rspamd_mempool_t * pool,
+ struct rspamd_task *task,
+ GTree ** tree)
{
- token_node_t *new = NULL;
- f_str_t headername;
- f_str_t headervalue;
+ token_node_t *new = NULL;
+ f_str_t headername;
+ f_str_t headervalue;
if (*tree == NULL) {
*tree = g_tree_new (token_node_compare_func);
- rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
+ rspamd_mempool_add_destructor (pool,
+ (rspamd_mempool_destruct_t) g_tree_destroy,
+ *tree);
}
#ifndef GMIME24
- struct raw_header *h;
+ struct raw_header *h;
h = GMIME_OBJECT (task->message)->headers->headers;
while (h) {
h = h->next;
}
#else
- GMimeHeaderList *ls;
- GMimeHeaderIter *iter;
- const char *name;
- const char *value;
+ GMimeHeaderList *ls;
+ GMimeHeaderIter *iter;
+ const char *name;
+ const char *value;
ls = GMIME_OBJECT (task->message)->headers;
iter = g_mime_header_iter_new ();
void
tokenize_subject (struct rspamd_task *task, GTree ** tree)
{
- f_str_t subject;
- const gchar *sub;
- struct tokenizer *osb_tokenizer;
+ f_str_t subject;
+ const gchar *sub;
+ struct tokenizer *osb_tokenizer;
if (*tree == NULL) {
*tree = g_tree_new (token_node_compare_func);
- rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
+ rspamd_mempool_add_destructor (task->task_pool,
+ (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
}
osb_tokenizer = get_tokenizer ("osb-text");
if (task->subject != NULL) {
subject.begin = task->subject;
subject.len = strlen (task->subject);
- osb_tokenizer->tokenize_func (osb_tokenizer, task->task_pool, &subject, tree, FALSE, TRUE, NULL);
+ osb_tokenizer->tokenize_func (osb_tokenizer,
+ task->task_pool,
+ &subject,
+ tree,
+ FALSE,
+ TRUE,
+ NULL);
}
if ((sub = g_mime_message_get_subject (task->message)) != NULL) {
subject.begin = (gchar *)sub;
subject.len = strlen (sub);
- osb_tokenizer->tokenize_func (osb_tokenizer, task->task_pool, &subject, tree, FALSE, TRUE, NULL);
+ osb_tokenizer->tokenize_func (osb_tokenizer,
+ task->task_pool,
+ &subject,
+ tree,
+ FALSE,
+ TRUE,
+ NULL);
}
}
#define TOKENIZERS_H
#include "config.h"
-#include "mem_pool.h"
#include "fstring.h"
#include "main.h"
+#include "mem_pool.h"
/* Size for features pipe */
#define FEATURE_WINDOW_SIZE 5
/* Common tokenizer structure */
struct tokenizer {
gchar *name;
- gint (*tokenize_func)(struct tokenizer *tokenizer, rspamd_mempool_t *pool, f_str_t *input,
- GTree **cur, gboolean save_token, gboolean is_utf, GList *exceptions);
- gchar* (*get_next_word)(f_str_t *buf, f_str_t *token, GList **exceptions);
+ gint (*tokenize_func)(struct tokenizer *tokenizer, rspamd_mempool_t *pool,
+ f_str_t *input,
+ GTree **cur, gboolean save_token, gboolean is_utf, GList *exceptions);
+ gchar * (*get_next_word)(f_str_t *buf, f_str_t *token, GList **exceptions);
};
/* Compare two token nodes */
int token_node_compare_func (gconstpointer a, gconstpointer b);
/* Get tokenizer structure by name or return NULL if this name is not found */
-struct tokenizer* get_tokenizer (const char *name);
+struct tokenizer * get_tokenizer (const char *name);
/* Get next word from specified f_str_t buf */
-gchar* get_next_word (f_str_t *buf, f_str_t *token, GList **exceptions);
+gchar * get_next_word (f_str_t *buf, f_str_t *token, GList **exceptions);
/* OSB tokenize function */
-int osb_tokenize_text (struct tokenizer *tokenizer, rspamd_mempool_t *pool, f_str_t *input,
- GTree **cur, gboolean save_token, gboolean is_utf, GList *exceptions);
+int osb_tokenize_text (struct tokenizer *tokenizer,
+ rspamd_mempool_t *pool,
+ f_str_t *input,
+ GTree **cur,
+ gboolean save_token,
+ gboolean is_utf,
+ GList *exceptions);
/* Common tokenizer for headers */
-int tokenize_headers (rspamd_mempool_t *pool, struct rspamd_task *task, GTree **cur);
+int tokenize_headers (rspamd_mempool_t *pool,
+ struct rspamd_task *task,
+ GTree **cur);
/* Make tokens for a subject */
void tokenize_subject (struct rspamd_task *task, GTree ** tree);
* Rspamd worker implementation
*/
+#include "cfg_file.h"
#include "config.h"
-#include "util.h"
+#include "dns.h"
#include "main.h"
+#include "map.h"
+#include "message.h"
#include "protocol.h"
#include "upstream.h"
-#include "cfg_file.h"
#include "url.h"
-#include "message.h"
-#include "map.h"
-#include "dns.h"
+#include "util.h"
#include "lua/lua_common.h"
void start_worker (struct rspamd_worker *worker);
worker_t normal_worker = {
- "normal", /* Name */
- init_worker, /* Init function */
- start_worker, /* Start function */
- TRUE, /* Has socket */
- FALSE, /* Non unique */
- FALSE, /* Non threaded */
- TRUE, /* Killable */
- SOCK_STREAM /* TCP socket */
+ "normal", /* Name */
+ init_worker, /* Init function */
+ start_worker, /* Start function */
+ TRUE, /* Has socket */
+ FALSE, /* Non unique */
+ FALSE, /* Non threaded */
+ TRUE, /* Killable */
+ SOCK_STREAM /* TCP socket */
};
/*
* Worker's context
*/
struct rspamd_worker_ctx {
- guint32 timeout;
- struct timeval io_tv;
- /* Detect whether this worker is mime worker */
- gboolean is_mime;
+ guint32 timeout;
+ struct timeval io_tv;
+ /* Detect whether this worker is mime worker */
+ gboolean is_mime;
/* HTTP worker */
- gboolean is_http;
- /* JSON output */
- gboolean is_json;
+ gboolean is_http;
+ /* JSON output */
+ gboolean is_json;
/* Allow learning throught worker */
- gboolean allow_learn;
+ gboolean allow_learn;
/* DNS resolver */
- struct rspamd_dns_resolver *resolver;
+ struct rspamd_dns_resolver *resolver;
/* Current tasks */
- guint32 tasks;
+ guint32 tasks;
/* Limit of tasks */
- guint32 max_tasks;
+ guint32 max_tasks;
/* Classify threads */
- guint32 classify_threads;
+ guint32 classify_threads;
/* Classify threads */
- GThreadPool *classify_pool;
+ GThreadPool *classify_pool;
/* Events base */
- struct event_base *ev_base;
+ struct event_base *ev_base;
};
/*
static void
reduce_tasks_count (gpointer arg)
{
- guint32 *tasks = arg;
+ guint32 *tasks = arg;
- (*tasks) --;
+ (*tasks)--;
}
static gint
rspamd_worker_body_handler (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg,
- const gchar *chunk, gsize len)
+ struct rspamd_http_message *msg,
+ const gchar *chunk, gsize len)
{
- struct rspamd_task *task = (struct rspamd_task *) conn->ud;
- struct rspamd_worker_ctx *ctx;
+ struct rspamd_task *task = (struct rspamd_task *) conn->ud;
+ struct rspamd_worker_ctx *ctx;
ctx = task->worker->ctx;
static void
rspamd_worker_error_handler (struct rspamd_http_connection *conn, GError *err)
{
- struct rspamd_task *task = (struct rspamd_task *) conn->ud;
+ struct rspamd_task *task = (struct rspamd_task *) conn->ud;
msg_info ("abnormally closing connection from: %s, error: %s",
- rspamd_inet_address_to_string (&task->client_addr), err->message);
+ rspamd_inet_address_to_string (&task->client_addr), err->message);
if (task->state != CLOSING_CONNECTION) {
/* We still need to write a reply */
task->error_code = err->code;
- task->last_error = rspamd_mempool_strdup (task->task_pool, err->message);
+ task->last_error =
+ rspamd_mempool_strdup (task->task_pool, err->message);
task->state = WRITE_REPLY;
rspamd_protocol_write_reply (task);
}
static gint
rspamd_worker_finish_handler (struct rspamd_http_connection *conn,
- struct rspamd_http_message *msg)
+ struct rspamd_http_message *msg)
{
- struct rspamd_task *task = (struct rspamd_task *) conn->ud;
+ struct rspamd_task *task = (struct rspamd_task *) conn->ud;
if (task->state == CLOSING_CONNECTION) {
msg_debug ("normally closing connection from: %s",
- rspamd_inet_address_to_string (&task->client_addr));
+ rspamd_inet_address_to_string (&task->client_addr));
destroy_session (task->s);
}
else {
static void
accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *) arg;
- struct rspamd_worker_ctx *ctx;
- struct rspamd_task *new_task;
- rspamd_inet_addr_t addr;
- gint nfd;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_worker_ctx *ctx;
+ struct rspamd_task *new_task;
+ rspamd_inet_addr_t addr;
+ gint nfd;
ctx = worker->ctx;
if (ctx->max_tasks != 0 && ctx->tasks > ctx->max_tasks) {
- msg_info ("current tasks is now: %uD while maximum is: %uD", ctx->tasks, ctx->max_tasks);
+ msg_info ("current tasks is now: %uD while maximum is: %uD",
+ ctx->tasks,
+ ctx->max_tasks);
return;
}
if ((nfd =
- rspamd_accept_from_socket (fd, &addr)) == -1) {
+ rspamd_accept_from_socket (fd, &addr)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
new_task = rspamd_task_new (worker);
msg_info ("accepted connection from %s port %d",
- rspamd_inet_address_to_string (&addr),
- rspamd_inet_address_get_port (&addr));
+ rspamd_inet_address_to_string (&addr),
+ rspamd_inet_address_get_port (&addr));
/* Copy some variables */
new_task->sock = nfd;
worker->srv->stat->connections_count++;
new_task->resolver = ctx->resolver;
- new_task->http_conn = rspamd_http_connection_new (rspamd_worker_body_handler,
- rspamd_worker_error_handler, rspamd_worker_finish_handler, 0, RSPAMD_HTTP_SERVER);
+ new_task->http_conn = rspamd_http_connection_new (
+ rspamd_worker_body_handler,
+ rspamd_worker_error_handler,
+ rspamd_worker_finish_handler,
+ 0,
+ RSPAMD_HTTP_SERVER);
new_task->ev_base = ctx->ev_base;
- ctx->tasks ++;
- rspamd_mempool_add_destructor (new_task->task_pool, (rspamd_mempool_destruct_t)reduce_tasks_count, &ctx->tasks);
+ ctx->tasks++;
+ rspamd_mempool_add_destructor (new_task->task_pool,
+ (rspamd_mempool_destruct_t)reduce_tasks_count, &ctx->tasks);
/* Set up async session */
new_task->s = new_async_session (new_task->task_pool, rspamd_task_fin,
- rspamd_task_restore, rspamd_task_free_hard, new_task);
+ rspamd_task_restore, rspamd_task_free_hard, new_task);
new_task->classify_pool = ctx->classify_pool;
- rspamd_http_connection_read_message (new_task->http_conn, new_task, nfd, &ctx->io_tv, ctx->ev_base);
+ rspamd_http_connection_read_message (new_task->http_conn,
+ new_task,
+ nfd,
+ &ctx->io_tv,
+ ctx->ev_base);
}
gpointer
init_worker (struct rspamd_config *cfg)
{
- struct rspamd_worker_ctx *ctx;
- GQuark type;
+ struct rspamd_worker_ctx *ctx;
+ GQuark type;
type = g_quark_try_string ("normal");
ctx->classify_threads = 1;
rspamd_rcl_register_worker_option (cfg, type, "mime",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_mime), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_mime), 0);
rspamd_rcl_register_worker_option (cfg, type, "http",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_http), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_http), 0);
rspamd_rcl_register_worker_option (cfg, type, "json",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_json), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_json), 0);
rspamd_rcl_register_worker_option (cfg, type, "allow_learn",
- rspamd_rcl_parse_struct_boolean, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, allow_learn), 0);
+ rspamd_rcl_parse_struct_boolean, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx, allow_learn), 0);
rspamd_rcl_register_worker_option (cfg, type, "timeout",
- rspamd_rcl_parse_struct_time, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
+ rspamd_rcl_parse_struct_time, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx,
+ timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
rspamd_rcl_register_worker_option (cfg, type, "max_tasks",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, max_tasks), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx,
+ max_tasks), RSPAMD_CL_FLAG_INT_32);
rspamd_rcl_register_worker_option (cfg, type, "classify_threads",
- rspamd_rcl_parse_struct_integer, ctx,
- G_STRUCT_OFFSET (struct rspamd_worker_ctx, classify_threads), RSPAMD_CL_FLAG_INT_32);
+ rspamd_rcl_parse_struct_integer, ctx,
+ G_STRUCT_OFFSET (struct rspamd_worker_ctx,
+ classify_threads), RSPAMD_CL_FLAG_INT_32);
return ctx;
}
void
start_worker (struct rspamd_worker *worker)
{
- struct rspamd_worker_ctx *ctx = worker->ctx;
- GError *err = NULL;
- struct lua_locked_state *nL;
+ struct rspamd_worker_ctx *ctx = worker->ctx;
+ GError *err = NULL;
+ struct lua_locked_state *nL;
ctx->ev_base = rspamd_prepare_worker (worker, "normal", accept_socket);
msec_to_tv (ctx->timeout, &ctx->io_tv);
start_map_watch (worker->srv->cfg, ctx->ev_base);
- ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
+ ctx->resolver = dns_resolver_init (worker->srv->logger,
+ ctx->ev_base,
+ worker->srv->cfg);
/* Create classify pool */
ctx->classify_pool = NULL;
if (ctx->classify_threads > 1) {
nL = init_lua_locked (worker->srv->cfg);
- ctx->classify_pool = g_thread_pool_new (process_statfiles_threaded, nL, ctx->classify_threads, TRUE, &err);
+ ctx->classify_pool = g_thread_pool_new (process_statfiles_threaded,
+ nL,
+ ctx->classify_threads,
+ TRUE,
+ &err);
if (err != NULL) {
msg_err ("pool create failed: %s", err->message);
ctx->classify_pool = NULL;
exit (EXIT_SUCCESS);
}
-/*
- * vi:ts=4
+/*
+ * vi:ts=4
*/
--- /dev/null
+tok_split_gte=false
+utf8_byte=false
+utf8_force=false
+indent_cmt_with_tabs=false
+indent_align_string=false
+indent_braces=false
+indent_braces_no_func=false
+indent_braces_no_class=false
+indent_braces_no_struct=false
+indent_brace_parent=false
+indent_namespace=false
+indent_extern=false
+indent_class=false
+indent_class_colon=false
+indent_else_if=false
+indent_var_def_cont=false
+indent_func_call_param=false
+indent_func_def_param=false
+indent_func_proto_param=false
+indent_func_class_param=false
+indent_func_ctor_var_param=false
+indent_template_param=false
+indent_func_param_double=false
+indent_relative_single_line_comments=false
+indent_col1_comment=false
+indent_access_spec_body=false
+indent_paren_nl=false
+indent_comma_paren=false
+indent_bool_paren=false
+indent_first_bool_expr=false
+indent_square_nl=false
+indent_preserve_sql=false
+indent_align_assign=true
+sp_balance_nested_parens=false
+align_keep_tabs=false
+align_with_tabs=true
+align_on_tabstop=false
+align_number_left=false
+align_func_params=false
+align_same_func_call_params=true
+align_var_def_colon=false
+align_var_def_attribute=false
+align_var_def_inline=false
+align_right_cmt_mix=false
+align_on_operator=false
+align_mix_var_proto=false
+align_single_line_func=false
+align_single_line_brace=false
+align_nl_cont=false
+align_left_shift=true
+align_oc_decl_colon=false
+nl_collapse_empty_body=false
+nl_assign_leave_one_liners=false
+nl_class_leave_one_liners=false
+nl_enum_leave_one_liners=false
+nl_getset_leave_one_liners=false
+nl_func_leave_one_liners=false
+nl_if_leave_one_liners=false
+nl_multi_line_cond=false
+nl_multi_line_define=false
+nl_before_case=false
+nl_after_case=false
+nl_after_return=false
+nl_after_semicolon=false
+nl_after_brace_open=false
+nl_after_brace_open_cmt=false
+nl_after_vbrace_open=false
+nl_after_vbrace_open_empty=false
+nl_after_brace_close=false
+nl_after_vbrace_close=false
+nl_define_macro=false
+nl_squeeze_ifdef=false
+nl_ds_struct_enum_cmt=false
+nl_ds_struct_enum_close_brace=false
+nl_create_if_one_liner=false
+nl_create_for_one_liner=false
+nl_create_while_one_liner=false
+ls_for_split_full=true
+ls_func_split_full=true
+nl_after_multiline_comment=false
+eat_blanks_after_open_brace=false
+eat_blanks_before_close_brace=false
+mod_full_brace_if_chain=false
+mod_pawn_semicolon=false
+mod_full_paren_if_bool=false
+mod_remove_extra_semicolon=false
+mod_sort_import=false
+mod_sort_using=false
+mod_sort_include=true
+mod_move_case_break=false
+mod_remove_empty_return=false
+cmt_indent_multi=true
+cmt_c_group=false
+cmt_c_nl_start=false
+cmt_c_nl_end=false
+cmt_cpp_group=false
+cmt_cpp_nl_start=false
+cmt_cpp_nl_end=false
+cmt_cpp_to_c=false
+cmt_star_cont=false
+cmt_multi_check_last=true
+cmt_insert_before_preproc=false
+pp_indent_at_level=false
+pp_region_indent_code=false
+pp_if_indent_code=false
+pp_define_at_level=false
+input_tab_size=4
+output_tab_size=4
+indent_columns=4
+indent_continue=4
+code_width=80
+indent_with_tabs=2
+sp_arith=force
+sp_assign=force
+sp_assign_default=force
+sp_before_assign=force
+sp_pp_concat=add
+sp_pp_stringify=add
+sp_bool=add
+sp_paren_brace=force
+sp_before_ptr_star=force
+sp_between_ptr_star=remove
+sp_after_type=force
+sp_before_sparen=force
+sp_sparen_brace=force
+sp_after_semi=add
+sp_after_semi_for=force
+sp_before_comma=remove
+sp_type_func=force
+sp_func_proto_paren=force
+sp_func_def_paren=force
+sp_func_call_paren=force
+sp_case_label=force
+nl_fcall_brace=force
+nl_func_type_name=force
--- /dev/null
+#!/bin/sh
+
+for d in src src/libserver src/client src/libmime src/libutil src/lua src/classifiers src/tokenizers src/plugins ; do
+ file_list=`find ${d} -maxdepth 1 -name "*.c" -or -name "*.h" -type f`
+ for file2indent in $file_list
+ do
+ echo "Indenting file $file2indent"
+ uncrustify -f "$file2indent" -c "./uncrustify.cfg" -o indentoutput.tmp
+ mv indentoutput.tmp "$file2indent"
+ done
+done
projects / thirdparty / rspamd.git / commitdiff
