ROOT ${PCRE_ROOT_DIR} MODULES pcre libpcre pcre3 libpcre3)
ENDIF()
-ProcessPackage(LIBEVENT LIBRARY event INCLUDE event.h INCLUDE_SUFFIXES include/event
- ROOT ${LIBEVENT_ROOT_DIR} MODULES event libevent)
ProcessPackage(SQLITE3 LIBRARY sqlite3 INCLUDE sqlite3.h INCLUDE_SUFFIXES include/sqlite3 include/sqlite
ROOT ${SQLITE3_ROOT_DIR} MODULES sqlite3 sqlite)
ProcessPackage(ICUDATA LIBRARY icudata INCLUDE unicode/ucnv.h
#include "config.h"
#include "unix-std.h"
-#include <event.h>
/*
* OpenBSD fix
}
static void
-rspamc_process_input (struct event_base *ev_base, struct rspamc_command *cmd,
+rspamc_process_input (struct ev_loop *ev_base, struct rspamc_command *cmd,
FILE *in, const gchar *name, GQueue *attrs)
{
struct rspamd_client_connection *conn;
}
static void
-rspamc_process_dir (struct event_base *ev_base, struct rspamc_command *cmd,
+rspamc_process_dir (struct ev_loop *ev_base, struct rspamc_command *cmd,
const gchar *name, GQueue *attrs)
{
DIR *d;
GPid cld;
struct rspamc_command *cmd;
FILE *in = NULL;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct stat st;
struct sigaction sigpipe_act;
gchar **exclude_pattern;
GString *server_name;
struct rspamd_cryptobox_pubkey *key;
struct rspamd_cryptobox_keypair *keypair;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct timeval timeout;
struct rspamd_http_connection *http_conn;
gboolean req_sent;
struct rspamd_client_connection *
rspamd_client_init (struct rspamd_http_context *http_ctx,
- struct event_base *ev_base, const gchar *name,
+ struct ev_loop *ev_base, const gchar *name,
guint16 port, gdouble timeout, const gchar *key)
{
struct rspamd_client_connection *conn;
#include "config.h"
#include "ucl.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
struct rspamd_client_connection;
struct rspamd_http_message;
*/
struct rspamd_client_connection * rspamd_client_init (
struct rspamd_http_context *http_ctx,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
const gchar *name,
guint16 port,
gdouble timeout,
struct rspamd_controller_worker_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
lua_csession_get_ev_base (lua_State *L)
{
struct rspamd_http_connection_entry *c = lua_check_controller_entry (L, 1);
- struct event_base **pbase;
+ struct ev_loop **pbase;
struct rspamd_controller_session *s;
if (c) {
s = c->ud;
- pbase = lua_newuserdata (L, sizeof (struct event_base *));
+ pbase = lua_newuserdata (L, sizeof (struct ev_loop *));
rspamd_lua_setclass (L, "rspamd{ev_base}", -1);
*pbase = s->ctx->ev_base;
}
struct rspamd_fuzzy_storage_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
struct hs_helper_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
#define DKIM_H_
#include "config.h"
-#include "event.h"
+#include "contrib/libev/ev.h"
#include "dns.h"
#include "ref.h"
* limitations under the License.
*/
-#include <contrib/librdns/rdns.h>
-#include <contrib/librdns/dns_private.h>
+
#include "config.h"
#include "dns.h"
#include "rspamd.h"
#include "utlist.h"
-#include "rdns_event.h"
+#include "contrib/librdns/rdns.h"
+#include "contrib/librdns/dns_private.h"
+#include "contrib/librdns/rdns_ev.h"
#include "unix-std.h"
static const gchar *M = "rspamd dns";
struct rspamd_dns_resolver *
rspamd_dns_resolver_init (rspamd_logger_t *logger,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_config *cfg)
{
struct rspamd_dns_resolver *dns_resolver;
dns_resolver = g_malloc0 (sizeof (struct rspamd_dns_resolver));
- dns_resolver->ev_base = ev_base;
+ dns_resolver->event_loop = ev_base;
if (cfg != NULL) {
dns_resolver->request_timeout = cfg->dns_timeout;
dns_resolver->max_retransmits = cfg->dns_retransmits;
}
dns_resolver->r = rdns_resolver_new ();
- rdns_bind_libevent (dns_resolver->r, dns_resolver->ev_base);
+ rdns_bind_libev (dns_resolver->r, dns_resolver->event_loop);
if (cfg != NULL) {
rdns_resolver_set_log_level (dns_resolver->r, cfg->log_level);
struct rspamd_dns_resolver {
struct rdns_resolver *r;
- struct event_base *ev_base;
+ struct ev_loop *event_loop;
struct upstream_list *ups;
struct rspamd_config *cfg;
gdouble request_timeout;
* Init DNS resolver, params are obtained from a config file or system file /etc/resolv.conf
*/
struct rspamd_dns_resolver * rspamd_dns_resolver_init (rspamd_logger_t *logger,
- struct event_base *ev_base, struct rspamd_config *cfg);
+ struct ev_loop *ev_base, struct rspamd_config *cfg);
struct rspamd_dns_request_ud;
/**
enum rspamd_fuzzy_backend_type type;
gdouble expire;
gdouble sync;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
rspamd_fuzzy_periodic_cb periodic_cb;
void *periodic_ud;
const struct rspamd_fuzzy_backend_subr *subr;
struct rspamd_fuzzy_backend *
-rspamd_fuzzy_backend_create (struct event_base *ev_base,
+rspamd_fuzzy_backend_create (struct ev_loop *ev_base,
const ucl_object_t *config,
struct rspamd_config *cfg,
GError **err)
g_free (bk);
}
-struct event_base*
+struct ev_loop*
rspamd_fuzzy_backend_event_base (struct rspamd_fuzzy_backend *backend)
{
return backend->ev_base;
#define SRC_LIBSERVER_FUZZY_BACKEND_H_
#include "config.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#include "fuzzy_wire.h"
struct rspamd_fuzzy_backend;
* @param err
* @return
*/
-struct rspamd_fuzzy_backend * rspamd_fuzzy_backend_create (struct event_base *ev_base,
+struct rspamd_fuzzy_backend * rspamd_fuzzy_backend_create (struct ev_loop *ev_base,
const ucl_object_t *config,
struct rspamd_config *cfg,
GError **err);
rspamd_fuzzy_periodic_cb cb,
void *ud);
-struct event_base* rspamd_fuzzy_backend_event_base (struct rspamd_fuzzy_backend *backend);
+struct ev_loop* rspamd_fuzzy_backend_event_base (struct rspamd_fuzzy_backend *backend);
gdouble rspamd_fuzzy_backend_get_expire (struct rspamd_fuzzy_backend *backend);
/**
redisAsyncContext *ctx;
struct event timeout;
const struct rspamd_fuzzy_cmd *cmd;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
float prob;
gboolean shingles_checked;
gboolean
rspamd_milter_handle_socket (gint fd, const struct timeval *tv,
rspamd_mempool_t *pool,
- struct event_base *ev_base, rspamd_milter_finish finish_cb,
+ struct ev_loop *ev_base, rspamd_milter_finish finish_cb,
rspamd_milter_error error_cb, void *ud)
{
struct rspamd_milter_session *session;
};
struct rspamd_email_address;
-struct event_base;
+struct ev_loop;
struct rspamd_http_message;
struct rspamd_config;
*/
gboolean rspamd_milter_handle_socket (gint fd, const struct timeval *tv,
rspamd_mempool_t *pool,
- struct event_base *ev_base, rspamd_milter_finish finish_cb,
+ struct ev_loop *ev_base, rspamd_milter_finish finish_cb,
rspamd_milter_error error_cb, void *ud);
/**
#include "config.h"
#include "libutil/mem_pool.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#include "khash.h"
#include "libutil/str_util.h"
struct timeval tv;
struct rspamd_milter_outbuf *out_chain;
struct timeval *ptv;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
rspamd_mempool_t *pool;
khash_t(milter_headers_hash_t) *headers;
gint cur_hdr;
struct rspamd_monitored_ctx {
struct rspamd_config *cfg;
struct rdns_resolver *resolver;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
GPtrArray *elts;
GHashTable *helts;
mon_change_cb change_cb;
void
rspamd_monitored_ctx_config (struct rspamd_monitored_ctx *ctx,
struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rdns_resolver *resolver,
mon_change_cb change_cb,
gpointer ud)
}
-struct event_base *
+struct ev_loop *
rspamd_monitored_ctx_get_ev_base (struct rspamd_monitored_ctx *ctx)
{
return ctx->ev_base;
*/
void rspamd_monitored_ctx_config (struct rspamd_monitored_ctx *ctx,
struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rdns_resolver *resolver,
mon_change_cb change_cb,
gpointer ud);
-struct event_base *rspamd_monitored_ctx_get_ev_base (struct rspamd_monitored_ctx *ctx);
+struct ev_loop *rspamd_monitored_ctx_get_ev_base (struct rspamd_monitored_ctx *ctx);
/**
* Create monitored object
*/
#include "config.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#include "redis_pool.h"
#include "cfg_file.h"
#include "contrib/hiredis/hiredis.h"
#include "contrib/hiredis/async.h"
-#include "contrib/hiredis/adapters/libevent.h"
+#include "contrib/hiredis/adapters/libev.h"
#include "cryptobox.h"
#include "logger.h"
};
struct rspamd_redis_pool {
- struct event_base *ev_base;
+ struct ev_loop *event_loop;
struct rspamd_config *cfg;
GHashTable *elts_by_key;
GHashTable *elts_by_ctx;
conn->ctx, real_timeout);
double_to_tv (real_timeout, &tv);
event_set (&conn->timeout, -1, EV_TIMEOUT, rspamd_redis_conn_timeout, conn);
- event_base_set (conn->elt->pool->ev_base, &conn->timeout);
+ event_base_set (conn->elt->pool->event_loop, &conn->timeout);
event_add (&conn->timeout, &tv);
}
REF_INIT_RETAIN (conn, rspamd_redis_pool_conn_dtor);
msg_debug_rpool ("created new connection to %s:%d: %p", ip, port, ctx);
- redisLibeventAttach (ctx, pool->ev_base);
+ redisLibevAttach (pool->event_loop, ctx);
redisAsyncSetDisconnectCallback (ctx, rspamd_redis_pool_on_disconnect,
conn);
void
rspamd_redis_pool_config (struct rspamd_redis_pool *pool,
struct rspamd_config *cfg,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
g_assert (pool != NULL);
- pool->ev_base = ev_base;
+ pool->event_loop = ev_base;
pool->cfg = cfg;
pool->timeout = default_timeout;
pool->max_conns = default_max_conns;
struct rspamd_redis_pool_connection *conn;
g_assert (pool != NULL);
- g_assert (pool->ev_base != NULL);
+ g_assert (pool->event_loop != NULL);
g_assert (ip != NULL);
key = rspamd_redis_pool_get_key (db, password, ip, port);
struct rspamd_redis_pool;
struct rspamd_config;
struct redisAsyncContext;
-struct event_base;
+struct ev_loop;
/**
* Creates new redis pool
*/
void rspamd_redis_pool_config (struct rspamd_redis_pool *pool,
struct rspamd_config *cfg,
- struct event_base *ev_base);
+ struct ev_loop *ev_base);
/**
event_set (&rep_elt->io_ev, wrk->control_pipe[0],
EV_READ | EV_PERSIST, handler,
rep_elt);
- event_base_set (rspamd_main->ev_base,
+ event_base_set (rspamd_main->event_loop,
&rep_elt->io_ev);
event_add (&rep_elt->io_ev, &worker_io_timeout);
struct rspamd_worker_control_data {
struct event io_ev;
struct rspamd_worker *worker;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct {
rspamd_worker_control_handler handler;
gpointer ud;
void
rspamd_control_worker_add_default_handler (struct rspamd_worker *worker,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
struct rspamd_worker_control_data *cd;
void
rspamd_srv_start_watching (struct rspamd_main *srv,
struct rspamd_worker *worker,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
g_assert (worker != NULL);
void
rspamd_srv_send_command (struct rspamd_worker *worker,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_srv_command *cmd,
gint attached_fd,
rspamd_srv_reply_handler handler,
#include "config.h"
#include "mem_pool.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
struct rspamd_main;
struct rspamd_worker;
* Register default handlers for a worker
*/
void rspamd_control_worker_add_default_handler (struct rspamd_worker *worker,
- struct event_base *ev_base);
+ struct ev_loop *ev_base);
/**
* Register custom handler for a specific control command for this worker
*/
void rspamd_srv_start_watching (struct rspamd_main *srv,
struct rspamd_worker *worker,
- struct event_base *ev_base);
+ struct ev_loop *ev_base);
/**
* end
*/
void rspamd_srv_send_command (struct rspamd_worker *worker,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_srv_command *cmd,
gint attached_fd,
rspamd_srv_reply_handler handler,
struct event resort_ev;
struct rspamd_symcache *cache;
struct rspamd_worker *w;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
};
/* weight, frequency, time */
}
static void
-rspamd_symcache_call_peak_cb (struct event_base *ev_base,
+rspamd_symcache_call_peak_cb (struct ev_loop *ev_base,
struct rspamd_symcache *cache,
struct rspamd_symcache_item *item,
gdouble cur_value,
gdouble cur_err)
{
lua_State *L = cache->cfg->lua_state;
- struct event_base **pbase;
+ struct ev_loop **pbase;
lua_rawgeti (L, LUA_REGISTRYINDEX, cache->peak_cb);
pbase = lua_newuserdata (L, sizeof (*pbase));
void
rspamd_symcache_start_refresh (struct rspamd_symcache *cache,
- struct event_base *ev_base, struct rspamd_worker *w)
+ struct ev_loop *ev_base, struct rspamd_worker *w)
{
struct timeval tv;
gdouble tm;
#include "ucl.h"
#include "cfg_file.h"
#include <lua.h>
-#include <event.h>
+#include "contrib/libev/ev.h"
struct rspamd_task;
struct rspamd_config;
* @param ev_base
*/
void rspamd_symcache_start_refresh (struct rspamd_symcache *cache,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_worker *w);
/**
rspamd_task_new (struct rspamd_worker *worker, struct rspamd_config *cfg,
rspamd_mempool_t *pool,
struct rspamd_lang_detector *lang_det,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
struct rspamd_task *new_task;
}
}
- new_task->ev_base = ev_base;
+ new_task->event_loop = ev_base;
#ifdef HAVE_EVENT_NO_CACHE_TIME_FUNC
if (ev_base) {
void *fin_arg; /**< argument for fin callback */
struct rspamd_dns_resolver *resolver; /**< DNS resolver */
- struct event_base *ev_base; /**< Event base */
+ struct ev_loop *event_loop; /**< Event base */
struct event timeout_ev; /**< Global task timeout */
struct event *guard_ev; /**< Event for input sanity guard */
struct rspamd_config *cfg,
rspamd_mempool_t *pool,
struct rspamd_lang_detector *lang_det,
- struct event_base *ev_base);
+ struct ev_loop *ev_base);
/**
* Destroy task object and remove its IO dispatcher if it exists
*/
void
rspamd_worker_set_signal_handler (int signo, struct rspamd_worker *worker,
- struct event_base *base,
+ struct ev_loop *base,
rspamd_worker_signal_handler handler,
void *handler_data)
{
}
void
-rspamd_worker_init_signals (struct rspamd_worker *worker, struct event_base *base)
+rspamd_worker_init_signals (struct rspamd_worker *worker, struct ev_loop *base)
{
struct sigaction signals;
/* We ignore these signals in the worker */
sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
}
-struct event_base *
+struct ev_loop *
rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
void (*accept_handler)(int, short, void *))
{
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct event *accept_events;
GList *cur;
struct rspamd_worker_listen_socket *ls;
rspamd_fork_worker (struct rspamd_main *rspamd_main,
struct rspamd_worker_conf *cf,
guint index,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
struct rspamd_worker *wrk;
gint rc;
#endif
/* Remove the inherited event base */
- event_reinit (rspamd_main->ev_base);
- event_base_free (rspamd_main->ev_base);
+ event_reinit (rspamd_main->event_loop);
+ event_base_free (rspamd_main->event_loop);
/* Drop privileges */
rspamd_worker_drop_priv (rspamd_main);
};
struct rspamd_worker_session_cache {
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
GHashTable *cache;
struct rspamd_config *cfg;
struct timeval tv;
void *
rspamd_worker_session_cache_new (struct rspamd_worker *w,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
struct rspamd_worker_session_cache *c;
static const gdouble periodic_interval = 60.0;
{
struct rspamd_worker *worker = ud;
struct rspamd_config *cfg = worker->srv->cfg;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
guchar tag[RSPAMD_MONITORED_TAG_LEN];
static struct rspamd_srv_command srv_cmd;
void
rspamd_worker_init_monitored (struct rspamd_worker *worker,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_dns_resolver *resolver)
{
rspamd_monitored_ctx_config (worker->srv->cfg->monitored_ctx,
* @param worker
* @param base
*/
-void rspamd_worker_init_signals (struct rspamd_worker *worker, struct event_base *base);
+void rspamd_worker_init_signals (struct rspamd_worker *worker, struct ev_loop *base);
/**
* Prepare worker's startup
* @param worker worker structure
* @param accept_handler handler of accept event for listen sockets
* @return event base suitable for a worker
*/
-struct event_base *
+struct ev_loop *
rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
void (*accept_handler)(int, short, void *));
*/
void rspamd_worker_set_signal_handler (int signo,
struct rspamd_worker *worker,
- struct event_base *base,
+ struct ev_loop *base,
rspamd_worker_signal_handler handler,
void *handler_data);
* @return
*/
void * rspamd_worker_session_cache_new (struct rspamd_worker *w,
- struct event_base *ev_base);
+ struct ev_loop *ev_base);
/**
* Adds a new session identified by pointer
* Fork new worker with the specified configuration
*/
struct rspamd_worker *rspamd_fork_worker (struct rspamd_main *,
- struct rspamd_worker_conf *, guint idx, struct event_base *ev_base);
+ struct rspamd_worker_conf *, guint idx, struct ev_loop *ev_base);
/**
* Sets crash signals handlers if compiled with libunwind
* @param resolver
*/
void rspamd_worker_init_monitored (struct rspamd_worker *worker,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_dns_resolver *resolver);
#define msg_err_main(...) rspamd_default_log_function (G_LOG_LEVEL_CRITICAL, \
#ifdef WITH_HIREDIS
#include "hiredis.h"
-#include "adapters/libevent.h"
+#include "adapters/libev.h"
#include "ref.h"
#define msg_debug_stat_redis(...) rspamd_conditional_debug_fast (NULL, NULL, \
struct rspamd_redis_stat_elt {
struct redis_stat_ctx *ctx;
struct rspamd_stat_async_elt *async;
- struct event_base *ev_base;
+ struct ev_loop *event_loop;
ucl_object_t *stat;
struct rspamd_redis_stat_cbdata *cbdata;
};
g_assert (cbdata->redis != NULL);
- redisLibeventAttach (cbdata->redis, redis_elt->ev_base);
+ redisLibevAttach (redis_elt->event_loop, cbdata->redis);
cbdata->inflight = 1;
cbdata->cur = ucl_object_typed_new (UCL_OBJECT);
backend->stcf = stf;
st_elt = g_malloc0 (sizeof (*st_elt));
- st_elt->ev_base = ctx->ev_base;
+ st_elt->event_loop = ctx->ev_base;
st_elt->ctx = backend;
backend->stat_elt = rspamd_stat_ctx_register_async (
rspamd_redis_async_stat_cb,
return NULL;
}
- redisLibeventAttach (rt->redis, task->ev_base);
+ redisLibevAttach (task->event_loop, rt->redis);
rspamd_redis_maybe_auth (ctx, rt->redis);
return rt;
event_del (&rt->timeout_event);
}
event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_timeout, rt);
- event_base_set (task->ev_base, &rt->timeout_event);
+ event_base_set (task->event_loop, &rt->timeout_event);
double_to_tv (rt->ctx->timeout, &tv);
event_add (&rt->timeout_event, &tv);
g_assert (rt->redis != NULL);
- redisLibeventAttach (rt->redis, task->ev_base);
+ redisLibevAttach (task->event_loop, rt->redis);
rspamd_redis_maybe_auth (rt->ctx, rt->redis);
/*
event_del (&rt->timeout_event);
}
event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_timeout, rt);
- event_base_set (task->ev_base, &rt->timeout_event);
+ event_base_set (task->event_loop, &rt->timeout_event);
double_to_tv (rt->ctx->timeout, &tv);
event_add (&rt->timeout_event, &tv);
gboolean
bayes_init (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_classifier *cl)
{
cl->cfg->flags |= RSPAMD_FLAG_CLASSIFIER_INTEGER;
#include "config.h"
#include "mem_pool.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#define RSPAMD_DEFAULT_CLASSIFIER "bayes"
/* Consider this value as 0 */
struct rspamd_stat_classifier {
char *name;
gboolean (*init_func)(struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_classifier *cl);
gboolean (*classify_func)(struct rspamd_classifier * ctx,
GPtrArray *tokens,
/* Bayes algorithm */
gboolean bayes_init (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_classifier *);
gboolean bayes_classify (struct rspamd_classifier *ctx,
GPtrArray *tokens,
/* Generic lua classifier */
gboolean lua_classifier_init (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_classifier *);
gboolean lua_classifier_classify (struct rspamd_classifier *ctx,
GPtrArray *tokens,
gboolean
lua_classifier_init (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_classifier *cl)
{
struct rspamd_lua_classifier_ctx *ctx;
#include "cryptobox.h"
#include "ucl.h"
#include "hiredis.h"
-#include "adapters/libevent.h"
+#include "adapters/libev.h"
#include "lua/lua_common.h"
#define REDIS_DEFAULT_TIMEOUT 0.5
g_assert (rt->redis != NULL);
- redisLibeventAttach (rt->redis, task->ev_base);
+ redisLibevAttach (task->event_loop, rt->redis);
/* Now check stats */
event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_cache_timeout, rt);
- event_base_set (task->ev_base, &rt->timeout_event);
+ event_base_set (task->event_loop, &rt->timeout_event);
rspamd_redis_cache_maybe_auth (ctx, rt->redis);
if (!learn) {
#include "config.h"
#include "task.h"
#include <lua.h>
-#include <event.h>
+#include "contrib/libev/ev.h"
/**
* @file stat_api.h
* Initialise statistics modules
* @param cfg
*/
-void rspamd_stat_init (struct rspamd_config *cfg, struct event_base *ev_base);
+void rspamd_stat_init (struct rspamd_config *cfg, struct ev_loop *ev_base);
/**
* Finalize statistics
};
void
-rspamd_stat_init (struct rspamd_config *cfg, struct event_base *ev_base)
+rspamd_stat_init (struct rspamd_config *cfg, struct ev_loop *ev_base)
{
GList *cur, *curst;
struct rspamd_classifier_config *clf;
struct rspamd_stat_tokenizer *tokenizer;
gpointer tkcf;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
};
typedef enum rspamd_learn_cache_result {
struct event *events;
const gdouble throttling = 0.5;
struct timeval tv;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
double_to_tv (throttling, &tv);
* limitations under the License.
*/
#include "config.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#include "aio_event.h"
#include "rspamd.h"
#include "unix-std.h"
* AIO context
*/
struct aio_context {
- struct event_base *base;
+ struct ev_loop *base;
gboolean has_aio; /**< Whether we have aio support on a system */
#ifdef LINUX
/* Eventfd variant */
* Initialize aio with specified event base
*/
struct aio_context *
-rspamd_aio_init (struct event_base *base)
+rspamd_aio_init (struct ev_loop *base)
{
struct aio_context *new;
/**
* Initialize aio with specified event base
*/
-struct aio_context * rspamd_aio_init (struct event_base *base);
+struct aio_context * rspamd_aio_init (struct ev_loop *base);
/**
* Open file for aio
#include "http_util.h"
#include "addr.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
enum rspamd_http_connection_type {
RSPAMD_HTTP_SERVER,
static struct rspamd_http_context*
rspamd_http_context_new_default (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct upstream_ctx *ups_ctx)
{
struct rspamd_http_context *ctx;
struct rspamd_http_context*
rspamd_http_context_create (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct upstream_ctx *ups_ctx)
{
struct rspamd_http_context *ctx;
struct rspamd_http_context*
rspamd_http_context_create_config (struct rspamd_http_context_cfg *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct upstream_ctx *ups_ctx)
{
struct rspamd_http_context *ctx;
rspamd_http_context_push_keepalive (struct rspamd_http_context *ctx,
struct rspamd_http_connection *conn,
struct rspamd_http_message *msg,
- struct event_base *ev_base)
+ struct ev_loop *ev_base)
{
struct rspamd_http_keepalive_cbdata *cbdata;
struct timeval tv;
#include "ucl.h"
#include "addr.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
struct rspamd_http_context;
struct rspamd_config;
* @return new context used for both client and server HTTP connections
*/
struct rspamd_http_context* rspamd_http_context_create (struct rspamd_config *cfg,
- struct event_base *ev_base, struct upstream_ctx *ctx);
+ struct ev_loop *ev_base, struct upstream_ctx *ctx);
struct rspamd_http_context* rspamd_http_context_create_config (
struct rspamd_http_context_cfg *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct upstream_ctx *ctx);
/**
* Destroys context
void rspamd_http_context_push_keepalive (struct rspamd_http_context *ctx,
struct rspamd_http_connection *conn,
struct rspamd_http_message *msg,
- struct event_base *ev_base);
+ struct ev_loop *ev_base);
#endif
struct upstream_list *http_proxies;
gpointer ssl_ctx;
gpointer ssl_ctx_noverify;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct event client_rotate_ev;
khash_t (rspamd_keep_alive_hash) *keep_alive_hash;
};
GPtrArray *regexps;
struct timeval tv;
struct timeval *ptv;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_http_context *ctx;
gchar *default_fs_path;
rspamd_http_router_handler_t unknown_method_handler;
/* Start watching event for all maps */
void
rspamd_map_watch (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_dns_resolver *resolver,
struct rspamd_worker *worker,
gboolean active_http)
#define RSPAMD_MAP_H
#include "config.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#include "ucl.h"
#include "mem_pool.h"
* Start watching of maps by adding events to libevent event loop
*/
void rspamd_map_watch (struct rspamd_config *cfg,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_dns_resolver *resolver,
struct rspamd_worker *worker,
gboolean active_http);
map_fin_cb_t fin_callback;
map_dtor_t dtor;
void **user_data;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_worker *wrk;
gchar *description;
gchar *name;
};
struct http_callback_data {
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_http_connection *conn;
rspamd_inet_addr_t *addr;
struct rspamd_map *map;
SSL *ssl;
gchar *hostname;
struct event *ev;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct timeval *tv;
rspamd_ssl_handler_t handler;
rspamd_ssl_error_handler_t err_handler;
}
struct rspamd_ssl_connection *
-rspamd_ssl_connection_new (gpointer ssl_ctx, struct event_base *ev_base,
+rspamd_ssl_connection_new (gpointer ssl_ctx, struct ev_loop *ev_base,
gboolean verify_peer)
{
struct rspamd_ssl_connection *c;
* @return opaque connection data
*/
struct rspamd_ssl_connection * rspamd_ssl_connection_new (gpointer ssl_ctx,
- struct event_base *ev_base, gboolean verify_peer);
+ struct ev_loop *ev_base, gboolean verify_peer);
/**
* Connects SSL session using the specified (connected) FD
struct upstream_ctx {
struct rdns_resolver *res;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct upstream_limits limits;
GQueue *upstreams;
gboolean configured;
void
rspamd_upstreams_library_config (struct rspamd_config *cfg,
struct upstream_ctx *ctx,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rdns_resolver *resolver)
{
g_assert (ctx != NULL);
* @param cfg
*/
void rspamd_upstreams_library_config (struct rspamd_config *cfg,
- struct upstream_ctx *ctx, struct event_base *ev_base,
+ struct upstream_ctx *ctx, struct ev_loop *ev_base,
struct rdns_resolver *resolver);
/**
}
#if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000000UL
-struct event_base *
+struct ev_loop *
event_get_base (struct event *ev)
{
return ev->ev_base;
#include <netdb.h>
#endif
-#include <event.h>
+#include "contrib/libev/ev.h"
#include <time.h>
struct rspamd_config;
*/
gboolean rspamd_constant_memcmp (const guchar *a, const guchar *b, gsize len);
-/* Special case for ancient libevent */
-#if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000000UL
-struct event_base * event_get_base (struct event *ev);
-#endif
-/* CentOS libevent */
-#ifndef evsignal_set
-#define evsignal_set(ev, x, cb, arg) \
- event_set((ev), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
-#endif
/* Avoid stupidity in libevent > 1.4 */
int rspamd_event_pending (struct event *ev, short what);
struct log_helper_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
struct rspamd_protocol_log_message_sum *sm;
struct rspamd_worker_lua_script *sc;
struct rspamd_config **pcfg;
- struct event_base **pevbase;
+ struct ev_loop **pevbase;
r = read (fd, buf, sizeof (buf));
return ud ? *((struct rspamd_async_session **)ud) : NULL;
}
-struct event_base*
+struct ev_loop*
lua_check_ev_base (lua_State * L, gint pos)
{
void *ud = rspamd_lua_check_udata (L, pos, "rspamd{ev_base}");
luaL_argcheck (L, ud != NULL, pos, "'event_base' expected");
- return ud ? *((struct event_base **)ud) : NULL;
+ return ud ? *((struct ev_loop **)ud) : NULL;
}
static void rspamd_lua_run_postloads_error (struct thread_entry *thread, int ret, const char *msg);
void
rspamd_lua_run_postloads (lua_State *L, struct rspamd_config *cfg,
- struct event_base *ev_base, struct rspamd_worker *w)
+ struct ev_loop *ev_base, struct rspamd_worker *w)
{
struct rspamd_config_cfg_lua_script *sc;
struct rspamd_config **pcfg;
- struct event_base **pev_base;
+ struct ev_loop **pev_base;
struct rspamd_worker **pw;
/* Execute post load scripts */
struct memory_pool_s * rspamd_lua_check_mempool (lua_State * L, gint pos);
struct rspamd_config * lua_check_config (lua_State * L, gint pos);
struct rspamd_async_session* lua_check_session (lua_State * L, gint pos);
-struct event_base* lua_check_ev_base (lua_State * L, gint pos);
+struct ev_loop* lua_check_ev_base (lua_State * L, gint pos);
struct rspamd_dns_resolver * lua_check_dns_resolver (lua_State * L, gint pos);
/**
* @param ev_base
*/
void rspamd_lua_run_postloads (lua_State *L, struct rspamd_config *cfg,
- struct event_base *ev_base, struct rspamd_worker *w);
+ struct ev_loop *ev_base, struct rspamd_worker *w);
void rspamd_lua_run_config_post_init (lua_State *L, struct rspamd_config *cfg);
void rspamd_lua_run_config_unload (lua_State *L, struct rspamd_config *cfg);
static void lua_periodic_callback_error (struct thread_entry *thread, int ret, const char *msg);
struct rspamd_lua_periodic {
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_config *cfg;
lua_State *L;
gdouble timeout;
{
struct rspamd_lua_periodic *periodic = ud;
struct rspamd_config **pcfg, *cfg;
- struct event_base **pev_base;
+ struct ev_loop **pev_base;
struct thread_entry *thread;
lua_State *L;
{
LUA_TRACE_POINT;
struct rspamd_config *cfg = lua_check_config (L, 1);
- struct event_base *ev_base = lua_check_ev_base (L, 2);
+ struct ev_loop *ev_base = lua_check_ev_base (L, 2);
gdouble timeout = lua_tonumber (L, 3);
struct timeval tv;
struct rspamd_lua_periodic *periodic;
rspamd_stat_init (cfg, NULL);
}
else if (strcmp (parts[i], "dns") == 0) {
- struct event_base *ev_base = lua_check_ev_base (L, 3);
+ struct ev_loop *ev_base = lua_check_ev_base (L, 3);
if (ev_base) {
cfg->dns_resolver = rspamd_dns_resolver_init (rspamd_logger_get_singleton (),
{
struct rspamd_dns_resolver *resolver, **presolver;
struct rspamd_config *cfg, **pcfg;
- struct event_base *base, **pbase;
+ struct ev_loop *base, **pbase;
/* Check args */
pbase = rspamd_lua_check_udata (L, 1, "rspamd{ev_base}");
struct fann *f = rspamd_lua_check_fann (L, 1);
guint ninputs, noutputs, ndata, i, j;
struct lua_fann_train_cbdata *cbdata;
- struct event_base *ev_base = lua_check_ev_base (L, 5);
+ struct ev_loop *ev_base = lua_check_ev_base (L, 5);
GError *err = NULL;
const guint max_epochs_default = 1000;
const gdouble desired_mse_default = 0.0001;
struct rspamd_async_session *session;
struct rspamd_symcache_item *item;
struct rspamd_http_message *msg;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_config *cfg;
struct rspamd_task *task;
struct timeval tv;
static const int default_http_timeout = 5000;
static struct rspamd_dns_resolver *
-lua_http_global_resolver (struct event_base *ev_base)
+lua_http_global_resolver (struct ev_loop *ev_base)
{
static struct rspamd_dns_resolver *global_resolver;
lua_http_request (lua_State *L)
{
LUA_TRACE_POINT;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_http_message *msg;
struct lua_http_cbdata *cbd;
struct rspamd_dns_resolver *resolver;
cbref = luaL_ref (L, LUA_REGISTRYINDEX);
if (lua_gettop (L) >= 3 && rspamd_lua_check_udata_maybe (L, 3, "rspamd{ev_base}")) {
- ev_base = *(struct event_base **)lua_touserdata (L, 3);
+ ev_base = *(struct ev_loop **)lua_touserdata (L, 3);
}
else {
ev_base = NULL;
if (lua_type (L, -1) == LUA_TUSERDATA) {
task = lua_check_task (L, -1);
- ev_base = task->ev_base;
+ ev_base = task->event_loop;
resolver = task->resolver;
session = task->s;
cfg = task->cfg;
lua_pushstring (L, "ev_base");
lua_gettable (L, 1);
if (rspamd_lua_check_udata_maybe (L, -1, "rspamd{ev_base}")) {
- ev_base = *(struct event_base **)lua_touserdata (L, -1);
+ ev_base = *(struct ev_loop **)lua_touserdata (L, -1);
}
else {
ev_base = NULL;
struct rspamd_task *task;
struct rspamd_symcache_item *item;
struct rspamd_async_session *s;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_config *cfg;
struct rspamd_redis_pool *pool;
gchar *server;
gint cbref = -1;
struct rspamd_config *cfg = NULL;
struct rspamd_async_session *session = NULL;
- struct event_base *ev_base = NULL;
+ struct ev_loop *ev_base = NULL;
gboolean ret = FALSE;
guint flags = 0;
else {
cfg = task->cfg;
session = task->s;
- ev_base = task->ev_base;
+ ev_base = task->event_loop;
ret = TRUE;
}
LUA_TRACE_POINT;
struct rspamd_task *task = NULL, **ptask;
struct rspamd_config *cfg = NULL;
- struct event_base *ev_base = NULL;
+ struct ev_loop *ev_base = NULL;
if (lua_type (L, 1) == LUA_TUSERDATA) {
gpointer p;
p = rspamd_lua_check_udata_maybe (L, 2, "rspamd{ev_base}");
if (p) {
- ev_base = *(struct event_base **)p;
+ ev_base = *(struct ev_loop **)p;
}
}
lua_task_get_ev_base (lua_State * L)
{
LUA_TRACE_POINT;
- struct event_base **pbase;
+ struct ev_loop **pbase;
struct rspamd_task *task = lua_check_task (L, 1);
if (task != NULL) {
- pbase = lua_newuserdata (L, sizeof (struct event_base *));
+ pbase = lua_newuserdata (L, sizeof (struct ev_loop *));
rspamd_lua_setclass (L, "rspamd{ev_base}", -1);
- *pbase = task->ev_base;
+ *pbase = task->event_loop;
}
else {
return luaL_error (L, "invalid arguments");
struct lua_tcp_cbdata {
struct rspamd_async_session *session;
struct rspamd_async_event *async_ev;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct timeval tv;
rspamd_inet_addr_t *addr;
GByteArray *in;
static const int default_tcp_timeout = 5000;
static struct rspamd_dns_resolver *
-lua_tcp_global_resolver (struct event_base *ev_base,
+lua_tcp_global_resolver (struct ev_loop *ev_base,
struct rspamd_config *cfg)
{
static struct rspamd_dns_resolver *global_resolver;
guint port;
gint cbref, tp, conn_cbref = -1;
gsize plen = 0;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct lua_tcp_cbdata *cbd;
struct rspamd_dns_resolver *resolver = NULL;
struct rspamd_async_session *session = NULL;
lua_gettable (L, -2);
if (lua_type (L, -1) == LUA_TUSERDATA) {
task = lua_check_task (L, -1);
- ev_base = task->ev_base;
+ ev_base = task->event_loop;
resolver = task->resolver;
session = task->s;
cfg = task->cfg;
lua_pushstring (L, "ev_base");
lua_gettable (L, -2);
if (rspamd_lua_check_udata_maybe (L, -1, "rspamd{ev_base}")) {
- ev_base = *(struct event_base **)lua_touserdata (L, -1);
+ ev_base = *(struct ev_loop **)lua_touserdata (L, -1);
}
else {
ev_base = NULL;
struct rspamd_async_session *session = NULL;
struct rspamd_dns_resolver *resolver = NULL;
struct rspamd_config *cfg = NULL;
- struct event_base *ev_base = NULL;
+ struct ev_loop *ev_base = NULL;
int arguments_validated = rspamd_lua_parse_table_arguments (L, 1, &err,
"task=U{task};session=U{session};resolver=U{resolver};ev_base=U{ev_base};"
if (task) {
cfg = task->cfg;
- ev_base = task->ev_base;
+ ev_base = task->event_loop;
session = task->s;
}
if (resolver == NULL) {
struct lua_udp_cbdata {
struct event io;
struct timeval tv;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_async_event *async_ev;
struct rspamd_task *task;
rspamd_mempool_t *pool;
LUA_TRACE_POINT;
const gchar *host;
guint port;
- struct event_base *ev_base = NULL;
+ struct ev_loop *ev_base = NULL;
struct lua_udp_cbdata *cbd;
struct rspamd_async_session *session = NULL;
struct rspamd_task *task = NULL;
lua_gettable (L, -2);
if (lua_type (L, -1) == LUA_TUSERDATA) {
task = lua_check_task (L, -1);
- ev_base = task->ev_base;
+ ev_base = task->event_loop;
session = task->s;
pool = task->task_pool;
}
lua_pushstring (L, "ev_base");
lua_gettable (L, -2);
if (rspamd_lua_check_udata_maybe (L, -1, "rspamd{ev_base}")) {
- ev_base = *(struct event_base **) lua_touserdata (L, -1);
+ ev_base = *(struct ev_loop **) lua_touserdata (L, -1);
} else {
ev_base = NULL;
}
lua_util_create_event_base (lua_State *L)
{
LUA_TRACE_POINT;
- struct event_base **pev_base;
+ struct ev_loop **pev_base;
- pev_base = lua_newuserdata (L, sizeof (struct event_base *));
+ pev_base = lua_newuserdata (L, sizeof (struct ev_loop *));
rspamd_lua_setclass (L, "rspamd{ev_base}", -1);
*pev_base = event_init ();
const gchar *message;
gsize mlen;
struct rspamd_task *task;
- struct event_base *base;
+ struct ev_loop *base;
ucl_object_t *res = NULL;
message = luaL_checklstring (L, 2, &mlen);
lua_ev_base_loop (lua_State *L)
{
int flags = 0;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
ev_base = lua_check_ev_base (L, 1);
if (lua_isnumber (L, 2)) {
GString *out_buf;
goffset out_pos;
struct rspamd_worker *wrk;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct event ev;
};
struct rspamd_lua_worker_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
lua_worker_get_ev_base (lua_State *L)
{
struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
- struct event_base **pbase;
+ struct ev_loop **pbase;
if (ctx) {
- pbase = lua_newuserdata (L, sizeof (struct event_base *));
+ pbase = lua_newuserdata (L, sizeof (struct ev_loop *));
rspamd_lua_setclass (L, "rspamd{ev_base}", -1);
*pbase = ctx->ev_base;
}
{
struct fuzzy_client_session *session = arg;
struct rspamd_task *task;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
gint r;
enum {
{
struct fuzzy_client_session *session = arg;
struct rspamd_task *task;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
task = session->task;
struct fuzzy_cmd_io *io;
struct rspamd_fuzzy_cmd *cmd = NULL;
const gchar *symbol, *ftype;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
gint r;
enum {
return_error = 0,
{
struct fuzzy_learn_session *session = arg;
struct rspamd_task *task;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
task = session->task;
event_set (&session->ev, sock, EV_WRITE, fuzzy_check_io_callback,
session);
- event_base_set (session->task->ev_base, &session->ev);
+ event_base_set (session->task->event_loop, &session->ev);
event_add (&session->ev, NULL);
evtimer_set (&session->timev, fuzzy_check_timer_callback,
session);
- event_base_set (session->task->ev_base, &session->timev);
+ event_base_set (session->task->event_loop, &session->timev);
event_add (&session->timev, &session->tv);
rspamd_session_add_event (task->s, fuzzy_io_fin, session, M);
evtimer_set (&s->timev, fuzzy_controller_timer_callback,
s);
- event_base_set (s->task->ev_base, &s->timev);
+ event_base_set (s->task->event_loop, &s->timev);
event_add (&s->timev, &s->tv);
(*saved)++;
s->session = task->s;
event_set (&s->ev, sock, EV_WRITE, fuzzy_controller_io_callback, s);
- event_base_set (task->ev_base, &s->ev);
+ event_base_set (task->event_loop, &s->ev);
event_add (&s->ev, NULL);
evtimer_set (&s->timev, fuzzy_controller_timer_callback, s);
- event_base_set (s->task->ev_base, &s->timev);
+ event_base_set (s->task->event_loop, &s->timev);
event_add (&s->timev, &s->tv);
rspamd_session_add_event (task->s,
#include "libutil/http_private.h"
#include "addr.h"
#include "unix-std.h"
-#include <event.h>
+#include "contrib/libev/ev.h"
#include "libutil/util.h"
#include "lua/lua_common.h"
end:
exit_tv.tv_sec = 0;
exit_tv.tv_usec = 0;
- event_base_loopexit (rspamd_main->ev_base, &exit_tv);
+ event_base_loopexit (rspamd_main->event_loop, &exit_tv);
return 0;
}
rspamd_http_connection_write_message (conn, msg, NULL, NULL, &cbdata,
&tv);
- event_base_loop (rspamd_main->ev_base, 0);
+ event_base_loop (rspamd_main->event_loop, 0);
rspamd_http_connection_unref (conn);
rspamd_inet_address_free (addr);
{
/* XXX: it's probably worth to add timeout here - not to wait forever */
while (rspamd_session_events_pending (rspamadm_session) > 0) {
- event_base_loop (rspamd_main->ev_base, EVLOOP_ONCE);
+ event_base_loop (rspamd_main->event_loop, EVLOOP_ONCE);
}
}
/* HTTP Server mode */
GPtrArray *addrs = NULL;
gchar *name = NULL;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct rspamd_http_connection_router *http;
gint fd;
struct rspamadm_lua_repl_context *ctx;
exit (EXIT_FAILURE);
}
- ev_base = rspamd_main->ev_base;
+ ev_base = rspamd_main->event_loop;
ctx = g_malloc0 (sizeof (*ctx));
http = rspamd_http_router_new (rspamadm_lua_error_handler,
rspamadm_lua_finish_handler,
rspamadm_add_lua_globals (struct rspamd_dns_resolver *resolver)
{
struct rspamd_async_session **psession;
- struct event_base **pev_base;
+ struct ev_loop **pev_base;
struct rspamd_dns_resolver **presolver;
rspamadm_session = rspamd_session_create (rspamd_main->cfg->cfg_pool, NULL,
*psession = rspamadm_session;
lua_setglobal (L, "rspamadm_session");
- pev_base = lua_newuserdata (L, sizeof (struct event_base *));
+ pev_base = lua_newuserdata (L, sizeof (struct ev_loop *));
rspamd_lua_setclass (L, "rspamd{ev_base}", -1);
- *pev_base = rspamd_main->ev_base;
+ *pev_base = rspamd_main->event_loop;
lua_setglobal (L, "rspamadm_ev_base");
presolver = lua_newuserdata (L, sizeof (struct rspamd_dns_resolver *));
event_config_set_flag (ev_cfg, EVENT_BASE_FLAG_NO_CACHE_TIME);
rspamd_main->ev_base = event_base_new_with_config (ev_cfg);
#else
- rspamd_main->ev_base = event_init ();
+ rspamd_main->event_loop = event_init ();
#endif
rspamadm_fill_internal_commands (all_commands);
(void) rspamd_log_open (rspamd_main->logger);
resolver = rspamd_dns_resolver_init (rspamd_main->logger,
- rspamd_main->ev_base,
+ rspamd_main->event_loop,
cfg);
- rspamd_main->http_ctx = rspamd_http_context_create (cfg, rspamd_main->ev_base,
+ rspamd_main->http_ctx = rspamd_http_context_create (cfg, rspamd_main->event_loop,
NULL);
g_log_set_default_handler (rspamd_glib_log_function, rspamd_main->logger);
rspamadm_add_lua_globals (resolver);
#ifdef WITH_HIREDIS
- rspamd_redis_pool_config (cfg->redis_pool, cfg, rspamd_main->ev_base);
+ rspamd_redis_pool_config (cfg->redis_pool, cfg, rspamd_main->event_loop);
#endif
/* Init rspamadm global */
cmd->run (0, NULL, cmd);
}
- event_base_loopexit (rspamd_main->ev_base, NULL);
+ event_base_loopexit (rspamd_main->event_loop, NULL);
#ifdef HAVE_EVENT_NO_CACHE_TIME_FLAG
event_config_free (ev_cfg);
#endif
event_del (&w->wait_ev);
rspamd_fork_worker (w->rspamd_main, w->cf, w->oldindex,
- w->rspamd_main->ev_base);
+ w->rspamd_main->event_loop);
REF_RELEASE (w->cf);
g_free (w);
}
tv.tv_usec = 0;
REF_RETAIN (cf);
event_set (&nw->wait_ev, -1, EV_TIMEOUT, rspamd_fork_delayed_cb, nw);
- event_base_set (rspamd_main->ev_base, &nw->wait_ev);
+ event_base_set (rspamd_main->event_loop, &nw->wait_ev);
event_add (&nw->wait_ev, &tv);
}
}
static void
-spawn_worker_type (struct rspamd_main *rspamd_main, struct event_base *ev_base,
+spawn_worker_type (struct rspamd_main *rspamd_main, struct ev_loop *ev_base,
struct rspamd_worker_conf *cf)
{
gint i;
}
static void
-spawn_workers (struct rspamd_main *rspamd_main, struct event_base *ev_base)
+spawn_workers (struct rspamd_main *rspamd_main, struct ev_loop *ev_base)
{
GList *cur, *ls;
struct rspamd_worker_conf *cf;
rspamd_log_nolock (rspamd_main->logger);
rspamd_pass_signal (rspamd_main->workers, signo);
- event_base_loopexit (rspamd_main->ev_base, NULL);
+ event_base_loopexit (rspamd_main->event_loop, NULL);
}
static void
rspamd_main->workers_gid);
reread_config (rspamd_main);
rspamd_check_core_limits (rspamd_main);
- spawn_workers (rspamd_main, rspamd_main->ev_base);
+ spawn_workers (rspamd_main, rspamd_main->event_loop);
}
static void
g_hash_table_foreach_remove (rspamd_main->workers, wait_for_workers, NULL);
if (g_hash_table_size (rspamd_main->workers) == 0) {
- event_base_loopexit (rspamd_main->ev_base, NULL);
+ event_base_loopexit (rspamd_main->event_loop, NULL);
}
}
worker_t **pworker;
GQuark type;
rspamd_inet_addr_t *control_addr = NULL;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct event term_ev, int_ev, cld_ev, hup_ev, usr1_ev, control_ev;
struct timeval term_tv;
struct rspamd_main *rspamd_main;
/* Init event base */
ev_base = event_init ();
- rspamd_main->ev_base = ev_base;
+ rspamd_main->event_loop = ev_base;
/* Unblock signals */
sigemptyset (&signals.sa_mask);
sigprocmask (SIG_SETMASK, &signals.sa_mask, NULL);
struct rspamd_abstract_worker_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
gint signo;
gboolean enabled;
struct event ev;
- struct event_base *base;
+ struct ev_loop *base;
struct rspamd_worker *worker;
struct rspamd_worker_signal_cb *cb;
};
gboolean is_privilleged; /**< true if run in privilleged mode */
gboolean cores_throttling; /**< turn off cores when limits are exceeded */
struct roll_history *history; /**< rolling history */
- struct event_base *ev_base;
+ struct ev_loop *event_loop;
struct rspamd_http_context *http_ctx;
};
GList *parts; /**< extracted mime parts */
struct rspamd_async_session * s; /**< async session object */
struct rspamd_dns_resolver *resolver; /**< DNS resolver */
- struct event_base *ev_base; /**< Event base */
+ struct ev_loop *ev_base; /**< Event base */
};
struct zstd_dictionary {
struct rspamd_proxy_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
if (!(task->flags & RSPAMD_TASK_FLAG_PROCESSING)) {
msg_info_task ("finishing actions has been processed, terminating");
- event_base_loopexit (task->ev_base, &tv);
+ event_base_loopexit (task->event_loop, &tv);
rspamd_session_destroy (task->s);
return TRUE;
event_set (guard_ev, task->sock, EV_READ|EV_PERSIST,
rspamd_worker_guard_handler, task);
#endif
- event_base_set (task->ev_base, guard_ev);
+ event_base_set (task->event_loop, guard_ev);
event_add (guard_ev, NULL);
task->guard_ev = guard_ev;
void
rspamd_worker_init_scanner (struct rspamd_worker *worker,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_dns_resolver *resolver,
struct rspamd_lang_detector **plang_det)
{
struct rspamd_worker_ctx {
guint64 magic;
/* Events base */
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
/* DNS resolver */
struct rspamd_dns_resolver *resolver;
/* Config */
* Init scanning routines
*/
void rspamd_worker_init_scanner (struct rspamd_worker *worker,
- struct event_base *ev_base,
+ struct ev_loop *ev_base,
struct rspamd_dns_resolver *resolver,
struct rspamd_lang_detector **plang_det);
#include "aio_event.h"
#include "unix-std.h"
-extern struct event_base *base;
+extern struct ev_loop *base;
static void
aio_read_cb (gint fd, gint res, gsize len, gpointer data, gpointer ud)
"oq3BLHap0GcMTTpSOgfQOKa8Df35Ns11JoOFjdBQ8GpM99kOrJP+vZcT8b7AMfthYm0Kwy"
"D9TjlkpScuoY5LjsWVnijh9dSNVLFqLatzg=;";
-extern struct event_base *base;
+extern struct ev_loop *base;
static void
test_key_handler (rspamd_dkim_key_t *key, gsize keylen, rspamd_dkim_context_t *ctx, gpointer ud, GError *err)
#include "cfg_file.h"
static guint requests = 0;
-extern struct event_base *base;
+extern struct ev_loop *base;
struct rspamd_dns_resolver *resolver;
gboolean
static void
rspamd_http_term_handler (gint fd, short what, void *arg)
{
- struct event_base *ev_base = arg;
+ struct ev_loop *ev_base = arg;
struct timeval tv = {0, 0};
event_base_loopexit (ev_base, &tv);
struct rspamd_cryptobox_keypair *kp, struct rspamd_keypair_cache *c)
{
struct rspamd_http_connection_router *rt;
- struct event_base *ev_base = event_init ();
+ struct ev_loop *ev_base = event_init ();
struct event accept_ev, term_ev;
rt = rspamd_http_router_new (rspamd_server_error, rspamd_server_finish,
struct rspamd_cryptobox_keypair *kp,
struct rspamd_cryptobox_pubkey *peer_kp,
struct rspamd_keypair_cache *c,
- struct event_base *ev_base, double *latency)
+ struct ev_loop *ev_base, double *latency)
{
struct rspamd_http_message *msg;
struct rspamd_http_connection *conn;
void
rspamd_http_test_func (void)
{
- struct event_base *ev_base = event_init ();
+ struct ev_loop *ev_base = event_init ();
rspamd_mempool_t *pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
struct rspamd_cryptobox_keypair *serv_key, *client_key;
struct rspamd_cryptobox_pubkey *peer_key;
#include "tests.h"
struct rspamd_main *rspamd_main = NULL;
-struct event_base *base = NULL;
+struct ev_loop *base = NULL;
worker_t *workers[] = { NULL };
gchar *lua_test = NULL;
{
struct upstream_list *ls, *nls;
struct upstream *up, *upn;
- struct event_base *ev_base = event_init ();
+ struct ev_loop *ev_base = event_init ();
struct rspamd_dns_resolver *resolver;
struct rspamd_config *cfg;
gint i, success = 0;
struct lat_elt *lat;
guint32 *wconns;
gdouble ts;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
};
static void
}
static void
-rspamd_http_client_func (struct event_base *ev_base, struct lat_elt *latency,
+rspamd_http_client_func (struct ev_loop *ev_base, struct lat_elt *latency,
guint32 *wconns,
struct rspamd_cryptobox_pubkey *peer_key,
struct rspamd_cryptobox_keypair* client_key,
rspamd_worker_func (struct lat_elt *plat, guint32 *wconns)
{
guint i, j;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
struct itimerval itv;
struct rspamd_keypair_cache *c = NULL;
struct rspamd_cryptobox_keypair *client_key = NULL;
GOptionContext *context;
GError *error = NULL;
pid_t *sfd;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
rspamd_mempool_t *pool = rspamd_mempool_new (8192, "http-bench");
struct event term_ev, int_ev, cld_ev;
guint64 total_done;
struct rspamd_http_server_session {
struct rspamd_http_connection *conn;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
guint req_size;
gboolean reply;
gint fd;
static void
rspamd_server_accept (gint fd, short what, void *arg)
{
- struct event_base *ev_base = arg;
+ struct ev_loop *ev_base = arg;
struct rspamd_http_server_session *session;
rspamd_inet_addr_t *addr;
gint nfd;
static void
rspamd_http_term_handler (gint fd, short what, void *arg)
{
- struct event_base *ev_base = arg;
+ struct ev_loop *ev_base = arg;
struct timeval tv = {0, 0};
event_base_loopexit (ev_base, &tv);
static void
rspamd_http_server_func (gint fd, rspamd_inet_addr_t *addr)
{
- struct event_base *ev_base = event_init ();
+ struct ev_loop *ev_base = event_init ();
struct event accept_ev, term_ev;
event_set (&accept_ev, fd, EV_READ | EV_PERSIST, rspamd_server_accept, ev_base);
{
GOptionContext *context;
GError *error = NULL;
- struct event_base *ev_base;
+ struct ev_loop *ev_base;
GString *b32_key;
pid_t *sfd;
rspamd_inet_addr_t *addr;
projects / thirdparty / rspamd.git / commitdiff
