Now all comments in commit logs beginning with '*' would be included in changelog, so
important changes would be separated from small ones.
static gboolean
binlog_check_file (struct rspamd_binlog *log)
{
- static char valid_magic[] = VALID_MAGIC, valid_version[] = VALID_VERSION;
+ 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));
struct rspamd_binlog*
-binlog_open (memory_pool_t *pool, const char *path, time_t rotate_time, int rotate_jitter)
+binlog_open (memory_pool_t *pool, const gchar *path, time_t rotate_time, gint rotate_jitter)
{
struct rspamd_binlog *new;
- int len = strlen (path);
+ gint len = strlen (path);
struct stat st;
new = memory_pool_alloc0 (pool, sizeof (struct rspamd_binlog));
/* Write index */
idx = &log->cur_idx->indexes[log->cur_idx->last_index];
idx->seek = seek;
- idx->time = (uint64_t)time (NULL);
+ 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) {
static gboolean
maybe_rotate_binlog (struct rspamd_binlog *log)
{
- uint64_t now = time (NULL);
+ guint64 now = time (NULL);
if (log->rotate_time && ((now - log->header.create_time) > log->rotate_time + log->rotate_jitter)) {
return TRUE;
static gboolean
rotate_binlog (struct rspamd_binlog *log)
{
- char *backup_name;
+ gchar *backup_name;
struct stat st;
lock_file (log->fd, FALSE);
}
gboolean
-binlog_sync (struct rspamd_binlog *log, uint64_t from_rev, uint64_t *from_time, GByteArray **rep)
+binlog_sync (struct rspamd_binlog *log, guint64 from_rev, guint64 *from_time, GByteArray **rep)
{
- uint32_t metaindex_num;
+ guint32 metaindex_num;
struct rspamd_index_block *idxb;
struct rspamd_binlog_index *idx;
gboolean idx_mapped = FALSE, res = TRUE, is_first = FALSE;
/* 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, (long unsigned)from_rev, (long unsigned)log->cur_seq, (long unsigned)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));
res = FALSE;
}
if (binlog_insert (log, nodes)) {
- msg_info ("set new revision of statfile %s: %ul", st->symbol, (long unsigned)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;
}
/* Assume 8 bytes words */
struct rspamd_binlog_header {
- char magic[3];
- char version[2];
- char padding[3];
- uint64_t create_time;
+ gchar magic[3];
+ gchar version[2];
+ gchar padding[3];
+ guint64 create_time;
};
struct rspamd_binlog_index {
- uint64_t time;
- uint64_t seek;
- uint32_t len;
+ guint64 time;
+ guint64 seek;
+ guint32 len;
};
struct rspamd_index_block {
struct rspamd_binlog_index indexes[BINLOG_IDX_LEN];
- uint32_t last_index;
+ guint32 last_index;
};
struct rspamd_binlog_metaindex {
- uint64_t indexes[METAINDEX_LEN];
- uint64_t last_index;
+ guint64 indexes[METAINDEX_LEN];
+ guint64 last_index;
};
struct rspamd_binlog_element {
- uint32_t h1;
- uint32_t h2;
+ guint32 h1;
+ guint32 h2;
float value;
} __attribute__((__packed__));
struct rspamd_binlog {
- char *filename;
+ gchar *filename;
time_t rotate_time;
- int rotate_jitter;
- uint64_t cur_seq;
- uint64_t cur_time;
- int fd;
+ gint rotate_jitter;
+ guint64 cur_seq;
+ guint64 cur_time;
+ gint fd;
memory_pool_t *pool;
struct rspamd_binlog_header header;
struct classifier_config;
-struct rspamd_binlog* binlog_open (memory_pool_t *pool, const char *path, time_t rotate_time, int rotate_jitter);
+struct rspamd_binlog* binlog_open (memory_pool_t *pool, const gchar *path, time_t rotate_time, gint rotate_jitter);
struct rspamd_binlog* get_binlog_by_statfile (struct statfile *st);
void binlog_close (struct rspamd_binlog *log);
gboolean binlog_insert (struct rspamd_binlog *log, GTree *nodes);
-gboolean binlog_sync (struct rspamd_binlog *log, uint64_t from_rev, uint64_t *from_time, GByteArray **rep);
+gboolean binlog_sync (struct rspamd_binlog *log, guint64 from_rev, guint64 *from_time, GByteArray **rep);
gboolean maybe_write_binlog (struct classifier_config *ccf, struct statfile *st, stat_file_t *file, GTree *nodes);
#endif
#define GETBIT(a, n) (a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)))
/* Common hash functions */
-unsigned int
-bloom_sax_hash (const char *key)
+guint
+bloom_sax_hash (const gchar *key)
{
- unsigned int h = 0;
+ guint h = 0;
while (*key)
- h ^= (h << 5) + (h >> 2) + (unsigned char)*key++;
+ h ^= (h << 5) + (h >> 2) + (gchar)*key++;
return h;
}
-unsigned int
-bloom_sdbm_hash (const char *key)
+guint
+bloom_sdbm_hash (const gchar *key)
{
- unsigned int h = 0;
+ guint h = 0;
while (*key)
- h = (unsigned char)*key++ + (h << 6) + (h << 16) - h;
+ h = (gchar)*key++ + (h << 6) + (h << 16) - h;
return h;
}
-unsigned int
-bloom_fnv_hash (const char *key)
+guint
+bloom_fnv_hash (const gchar *key)
{
- unsigned int h = 0;
+ guint h = 0;
while (*key) {
- h ^= (unsigned char)*key++;
+ h ^= (gchar)*key++;
h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
}
return h;
}
-unsigned int
-bloom_rs_hash (const char *key)
+guint
+bloom_rs_hash (const gchar *key)
{
- unsigned int b = 378551;
- unsigned int a = 63689;
- unsigned int hash = 0;
+ guint b = 378551;
+ guint a = 63689;
+ guint hash = 0;
while (*key) {
- hash = hash * a + (unsigned char)*key++;
+ hash = hash * a + (gchar)*key++;
a = a * b;
}
return hash;
}
-unsigned int
-bloom_js_hash (const char *key)
+guint
+bloom_js_hash (const gchar *key)
{
- unsigned int hash = 1315423911;
+ guint hash = 1315423911;
while (*key) {
- hash ^= ((hash << 5) + (unsigned char)*key++ + (hash >> 2));
+ hash ^= ((hash << 5) + (gchar)*key++ + (hash >> 2));
}
return hash;
}
-unsigned int
-bloom_elf_hash (const char *key)
+guint
+bloom_elf_hash (const gchar *key)
{
- unsigned int hash = 0;
- unsigned int x = 0;
+ guint hash = 0;
+ guint x = 0;
while (*key) {
- hash = (hash << 4) + (unsigned char)*key++;
+ hash = (hash << 4) + (gchar)*key++;
if ((x = hash & 0xF0000000L) != 0) {
hash ^= (x >> 24);
}
}
-unsigned int
-bloom_bkdr_hash (const char *key)
+guint
+bloom_bkdr_hash (const gchar *key)
{
- unsigned int seed = 131; /* 31 131 1313 13131 131313 etc.. */
- unsigned int hash = 0;
+ guint seed = 131; /* 31 131 1313 13131 131313 etc.. */
+ guint hash = 0;
while (*key) {
- hash = (hash * seed) + (unsigned char)*key++;
+ hash = (hash * seed) + (gchar)*key++;
}
return hash;
}
-unsigned int
-bloom_ap_hash (const char *key)
+guint
+bloom_ap_hash (const gchar *key)
{
- unsigned int hash = 0xAAAAAAAA;
- unsigned int i = 0;
+ guint hash = 0xAAAAAAAA;
+ guint i = 0;
while (*key) {
- hash ^= ((i & 1) == 0) ? ((hash << 7) ^ ((unsigned char)*key) * (hash >> 3)) : (~((hash << 11) + (((unsigned char)*key) ^ (hash >> 5))));
+ hash ^= ((i & 1) == 0) ? ((hash << 7) ^ ((gchar)*key) * (hash >> 3)) : (~((hash << 11) + (((gchar)*key) ^ (hash >> 5))));
key++;
}
{
bloom_filter_t *bloom;
va_list l;
- int n;
+ gint n;
if (!(bloom = g_malloc (sizeof (bloom_filter_t)))) {
return NULL;
}
- if (!(bloom->a = g_new0 (char, (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
-bloom_add (bloom_filter_t * bloom, const char *s)
+bloom_add (bloom_filter_t * bloom, const gchar *s)
{
size_t n;
u_char t;
}
gboolean
-bloom_del (bloom_filter_t * bloom, const char *s)
+bloom_del (bloom_filter_t * bloom, const gchar *s)
{
size_t n;
u_char t;
}
gboolean
-bloom_check (bloom_filter_t * bloom, const char *s)
+bloom_check (bloom_filter_t * bloom, const gchar *s)
{
size_t n;
#include "config.h"
-typedef unsigned int (*hashfunc_t) (const char *);
+typedef guint (*hashfunc_t) (const gchar *);
typedef struct bloom_filter_s {
size_t asize;
- unsigned char *a;
+ gchar *a;
size_t nfuncs;
hashfunc_t *funcs;
} bloom_filter_t;
/* Hash functions */
-unsigned int bloom_sax_hash (const char *key);
-unsigned int bloom_sdbm_hash (const char *key);
-unsigned int bloom_fnv_hash (const char *key);
-unsigned int bloom_rs_hash (const char *key);
-unsigned int bloom_js_hash (const char *key);
-unsigned int bloom_elf_hash (const char *key);
-unsigned int bloom_bkdr_hash (const char *key);
-unsigned int bloom_ap_hash (const char *key);
+guint bloom_sax_hash (const gchar *key);
+guint bloom_sdbm_hash (const gchar *key);
+guint bloom_fnv_hash (const gchar *key);
+guint bloom_rs_hash (const gchar *key);
+guint bloom_js_hash (const gchar *key);
+guint bloom_elf_hash (const gchar *key);
+guint bloom_bkdr_hash (const gchar *key);
+guint bloom_ap_hash (const gchar *key);
#define DEFAULT_BLOOM_HASHES 8, bloom_sax_hash, bloom_sdbm_hash, bloom_fnv_hash, bloom_rs_hash, bloom_js_hash, bloom_elf_hash, bloom_bkdr_hash, bloom_ap_hash
bloom_filter_t* bloom_create (size_t size, size_t nfuncs, ...);
void bloom_destroy (bloom_filter_t * bloom);
-gboolean bloom_add (bloom_filter_t * bloom, const char *s);
-gboolean bloom_del (bloom_filter_t * bloom, const char *s);
-gboolean bloom_check (bloom_filter_t * bloom, const char *s);
+gboolean bloom_add (bloom_filter_t * bloom, const gchar *s);
+gboolean bloom_del (bloom_filter_t * bloom, const gchar *s);
+gboolean bloom_check (bloom_filter_t * bloom, const gchar *s);
#endif
#define G_DISPATCHER_ERROR dispatcher_error_quark()
-static void dispatcher_cb (int fd, short what, void *arg);
+static void dispatcher_cb (gint fd, short what, void *arg);
static inline GQuark
dispatcher_error_quark (void)
static gboolean
sendfile_callback (rspamd_io_dispatcher_t *d)
{
- ssize_t r;
+
GError *err;
#ifdef HAVE_SENDFILE
d->in_sendfile = FALSE;
}
# else
+ ssize_t r;
/* Linux version */
r = sendfile (d->fd, d->sendfile_fd, &d->offset, d->file_size);
if (r == -1) {
}
# endif
#else
+ ssize_t r;
r = write (d->fd, d->map, d->file_size - d->offset);
if (r == -1) {
if (errno != EAGAIN) {
#define BUFREMAIN(x) (x)->data->size - ((x)->pos - (x)->data->begin)
static gboolean
-write_buffers (int fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
+write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
{
GList *cur;
GError *err;
}
static void
-read_buffers (int fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
+read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
{
ssize_t r;
GError *err;
f_str_t res;
- char *c, *b;
- char *end;
+ gchar *c, *b;
+ gchar *end;
size_t len;
enum io_policy saved_policy;
#undef BUFREMAIN
static void
-dispatcher_cb (int fd, short what, void *arg)
+dispatcher_cb (gint fd, short what, void *arg)
{
rspamd_io_dispatcher_t *d = (rspamd_io_dispatcher_t *) arg;
GError *err;
- debug_ip (d->peer_addr, "in dispatcher callback, what: %d, fd: %d", (int)what, fd);
+ debug_ip (d->peer_addr, "in dispatcher callback, what: %d, fd: %d", (gint)what, fd);
switch (what) {
case EV_TIMEOUT:
rspamd_io_dispatcher_t *
-rspamd_create_dispatcher (int fd, enum io_policy policy,
+rspamd_create_dispatcher (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_set_dispatcher_policy (rspamd_io_dispatcher_t * d, enum io_policy policy, size_t nchars)
{
f_str_t *tmp;
- int t;
+ gint t;
if (d->policy != policy) {
d->policy = policy;
newbuf = memory_pool_alloc (d->pool, sizeof (rspamd_buffer_t));
if (len == 0) {
/* Assume NULL terminated */
- len = strlen ((char *)data);
+ len = strlen ((gchar *)data);
}
if (!allocated) {
gboolean
-rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, int fd, size_t len)
+rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len)
{
if (lseek (fd, 0, SEEK_SET) == -1) {
msg_warn ("lseek failed: %s", strerror (errno));
*/
typedef struct rspamd_buffer_s {
f_str_t *data; /**< buffer logic */
- char *pos; /**< current position */
+ gchar *pos; /**< current position */
} rspamd_buffer_t;
typedef struct rspamd_io_dispatcher_s {
memory_pool_t *pool; /**< where to store data */
enum io_policy policy; /**< IO policy */
size_t nchars; /**< how many chars to read */
- int fd; /**< descriptor */
- uint32_t peer_addr; /**< address of peer for debugging */
+ 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 */
void *user_data; /**< user's data for callbacks */
off_t offset; /**< for sendfile use */
size_t file_size;
- int sendfile_fd;
+ gint sendfile_fd;
gboolean in_sendfile; /**< whether buffer is in sendfile mode */
gboolean strip_eol; /**< strip or not line ends in BUFFER_LINE policy */
#ifndef HAVE_SENDFILE
* @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 (int fd,
+rspamd_io_dispatcher_t* rspamd_create_dispatcher (gint fd,
enum io_policy policy,
dispatcher_read_callback_t read_cb,
dispatcher_write_callback_t write_cb,
* @param fd descriptor of file
* @param len length of data
*/
-gboolean rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, int 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
struct memcached_server {
struct upstream up; /**< common upstream base */
struct in_addr addr; /**< address of server */
- uint16_t port; /**< port to connect */
+ guint16 port; /**< port to connect */
short alive; /**< is this server alive */
- short int num; /**< number of servers in case of mirror */
+ gint16 num; /**< number of servers in case of mirror */
};
/**
* Statfile section definition
*/
struct statfile_section {
- uint32_t code; /**< section's code */
- uint64_t size; /**< size of section */
+ guint32 code; /**< section's code */
+ guint64 size; /**< size of section */
double weight; /**< weight coefficient for section */
};
enum sync_affinity affinity;
time_t rotate_time;
struct in_addr master_addr;
- uint16_t master_port;
+ guint16 master_port;
};
typedef double (*statfile_normalize_func)(struct config_file *cfg, long double score, void *params);
* Config params for rspamd worker
*/
struct worker_conf {
- int type; /**< worker type */
+ gint type; /**< worker type */
gchar *bind_host; /**< bind line */
struct in_addr bind_addr; /**< bind address in case of TCP socket */
- uint16_t bind_port; /**< bind port in case of TCP socket */
- uint16_t bind_family; /**< bind type (AF_UNIX or AF_INET) */
- uint16_t count; /**< number of workers */
- int listen_sock; /**< listening socket desctiptor */
- uint32_t rlimit_nofile; /**< max files limit */
- uint32_t rlimit_maxcore; /**< maximum core file size */
+ guint16 bind_port; /**< bind port in case of TCP socket */
+ guint16 bind_family; /**< bind type (AF_UNIX or AF_INET) */
+ guint16 count; /**< number of workers */
+ gint listen_sock; /**< listening socket desctiptor */
+ 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 */
gboolean convert_config; /**< convert config to XML format */
enum rspamd_log_type log_type; /**< log type */
- int log_facility; /**< log facility in case of syslog */
- int log_level; /**< log level trigger */
+ 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 */
- uint32_t log_buf_size; /**< length of log buffer */
+ 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 */
struct memcached_server memcached_servers[MAX_MEMCACHED_SERVERS]; /**< memcached servers */
gsize memcached_servers_num; /**< number of memcached servers */
memc_proto_t memcached_protocol; /**< memcached protocol */
- unsigned int memcached_error_time; /**< memcached error time (see upstream documentation) */
- unsigned int memcached_dead_time; /**< memcached dead time */
- unsigned int memcached_maxerrors; /**< maximum number of errors */
- unsigned int memcached_connect_timeout; /**< connection timeout */
+ guint memcached_error_time; /**< memcached error time (see upstream documentation) */
+ guint memcached_dead_time; /**< memcached dead time */
+ guint memcached_maxerrors; /**< maximum number of errors */
+ guint memcached_connect_timeout; /**< connection timeout */
gboolean delivery_enable; /**< is delivery agent is enabled */
gchar *deliver_host; /**< host for mail deliviring */
GHashTable* user_settings; /**< settings per-user */
gchar* domain_settings_str; /**< string representation of settings */
gchar* user_settings_str;
- int clock_res; /**< resolution of clock used */
+ gint clock_res; /**< resolution of clock used */
struct symbols_cache *cache; /**< symbols cache object */
- char *cache_filename; /**< filename of cache file */
+ gchar *cache_filename; /**< filename of cache file */
struct metric *default_metric; /**< default metric */
gchar* checksum; /**< real checksum of config file */
* @param port port
* @return TRUE if string was parsed
*/
-gboolean parse_host_port (const gchar *str, struct in_addr *ina, uint16_t *port);
+gboolean parse_host_port (const gchar *str, struct in_addr *ina, guint16 *port);
/**
* Parse bind credits
* @param type type of credits
* @return 1 if line was successfully parsed and 0 in case of error
*/
-int parse_bind_line (struct config_file *cfg, struct worker_conf *cf, gchar *str);
+gint parse_bind_line (struct config_file *cfg, struct worker_conf *cf, gchar *str);
/**
* Init default values
* @param t string representation of seconds (eg. 1D)
* @return numeric value of string
*/
-unsigned int parse_seconds (const gchar *t);
+guint parse_seconds (const gchar *t);
/**
* Parse flag
gboolean
-parse_host_port (const gchar *str, struct in_addr *ina, uint16_t *port)
+parse_host_port (const gchar *str, struct in_addr *ina, guint16 *port)
{
gchar **tokens, *err_str;
struct hostent *hent;
- unsigned int port_parsed, saved_errno = errno;
+ guint port_parsed, saved_errno = errno;
tokens = g_strsplit_set (str, ":", 0);
if (!tokens || !tokens[0]) {
return FALSE;
}
-int
+gint
parse_bind_line (struct config_file *cfg, struct worker_conf *cf, gchar *str)
{
gchar **host;
- int16_t *family, *port;
+ gint16 *family, *port;
struct in_addr *addr;
if (str == NULL)
#ifdef HAVE_DIRNAME
/* Try to check path of bind credit */
struct stat st;
- int fd;
+ gint fd;
gchar *copy = memory_pool_strdup (cfg->cfg_pool, str);
if (stat (copy, &st) == -1) {
if (errno == ENOENT) {
{
GList *cur_opt;
struct module_opt *cur;
- static char numbuf[64];
+ static gchar numbuf[64];
cur_opt = g_hash_table_lookup (cfg->modules_opts, module_name);
if (cur_opt == NULL) {
snprintf (numbuf, sizeof (numbuf), "%s", *(gboolean *)cur->actual_data ? "yes" : "no");
return numbuf;
case LUA_VAR_STRING:
- return (char *)cur->actual_data;
+ return (gchar *)cur->actual_data;
case LUA_VAR_FUNCTION:
msg_info ("option %s is dynamic, so it cannot be aqquired statically", opt_name);
return NULL;
return result;
}
-unsigned int
+guint
parse_seconds (const gchar *t)
{
- unsigned int result = 0;
+ guint result = 0;
gchar *err_str;
if (!t || *t == '\0')
{
gchar **strvec, **p;
struct filter *cur;
- int i;
+ gint i;
if (str == NULL) {
return;
gboolean
get_config_checksum (struct config_file *cfg)
{
- int fd;
+ gint fd;
void *map;
struct stat st;
clock_getres (CLOCK_REALTIME, &ts);
# endif
- cfg->clock_res = (int)log10 (1000000 / ts.tv_nsec);
+ cfg->clock_res = (gint)log10 (1000000 / ts.tv_nsec);
if (cfg->clock_res < 0) {
cfg->clock_res = 0;
}
{
va_list aq;
gchar logbuf[BUFSIZ], readbuf[32];
- int r;
+ gint r;
va_start (aq, fmt);
g_strlcpy (readbuf, yytext, sizeof (readbuf));
{
va_list aq;
gchar logbuf[BUFSIZ], readbuf[32];
- int r;
+ gint r;
va_start (aq, fmt);
g_strlcpy (readbuf, yytext, sizeof (readbuf));
{
gchar *code_begin;
GList *params = NULL;
- int len;
+ gint len;
code_begin = strchr (line, ':');
read_xml_config (struct config_file *cfg, const gchar *filename)
{
struct stat st;
- int fd;
+ gint fd;
gchar *data;
gboolean res;
GMarkupParseContext *ctx;
};
struct xml_config_param {
- const char *name;
+ const gchar *name;
element_handler_func handler;
- int offset;
+ gint offset;
gpointer user_data;
};
return FALSE;
}
-static inline char*
+static inline gchar*
xml_asciiz_string (memory_pool_t *pool, const gchar *text, gsize len)
{
- char *val;
+ gchar *val;
val = memory_pool_alloc (pool, len + 1);
g_strlcpy (val, text, len + 1);
{
struct xml_parser_rule *rule;
struct xml_config_param *param;
- int i;
+ gint i;
/* First find required section */
for (i = 0; i < G_N_ELEMENTS (grammar); i ++) {
/* Logging section */
gboolean
-handle_log_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_log_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
- char *val;
+ gchar *val;
if (g_ascii_strcasecmp (data, "file") == 0) {
/* Find filename attribute */
if ((val = g_hash_table_lookup (attrs, "filename")) == NULL) {
}
gboolean
-handle_log_level (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_log_level (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
if (g_ascii_strcasecmp (data, "error") == 0) {
cfg->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
/* Worker section */
gboolean
-worker_handle_param (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+worker_handle_param (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct worker_conf *wrk = ctx->section_pointer;
- char *name;
+ gchar *name;
if ((name = g_hash_table_lookup (attrs, "name")) == NULL) {
msg_err ("worker param tag must have \"name\" attribute");
return TRUE;
}
gboolean
-worker_handle_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+worker_handle_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct worker_conf *wrk = ctx->section_pointer;
}
gboolean
-worker_handle_bind (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+worker_handle_bind (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct worker_conf *wrk = ctx->section_pointer;
}
gboolean
-handle_metric_action (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_metric_action (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct metric *metric = ctx->section_pointer;
gchar *p, *errstr;
}
gboolean
-handle_metric_symbol (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_metric_symbol (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
- char *strval, *err;
+ gchar *strval, *err;
double *value;
GList *metric_list;
struct metric *metric = ctx->section_pointer;
/* Modules section */
gboolean
-handle_module_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_module_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
- char *name, *val;
+ gchar *name, *val;
GList *cur_opt;
struct module_opt *cur;
gboolean is_lua = FALSE;
/* Handle lua tag */
gboolean
-handle_lua (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_lua (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
gchar *val, *cur_dir, *lua_dir, *lua_file, *tmp1, *tmp2;
lua_State *L = cfg->lua_state;
/* Modules section */
gboolean
-handle_module_path (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_module_path (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct stat st;
struct script_module *cur;
glob_t globbuf;
- char *pattern;
+ gchar *pattern;
size_t len;
- int i;
+ gint i;
if (stat (data, &st) == -1) {
msg_err ("cannot stat path %s, %s", data, strerror (errno));
/* Variables and composites */
gboolean
-handle_variable (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_variable (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
gchar *val;
}
gboolean
-handle_composite (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_composite (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
gchar *val;
struct expression *expr;
/* View section */
gboolean
-handle_view_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_view_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct rspamd_view *view = ctx->section_pointer;
return TRUE;
}
gboolean
-handle_view_client_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_view_client_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct rspamd_view *view = ctx->section_pointer;
return TRUE;
}
gboolean
-handle_view_from (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_view_from (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct rspamd_view *view = ctx->section_pointer;
return TRUE;
}
gboolean
-handle_view_rcpt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_view_rcpt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct rspamd_view *view = ctx->section_pointer;
return TRUE;
}
gboolean
-handle_view_symbols (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_view_symbols (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct rspamd_view *view = ctx->section_pointer;
/* Settings */
gboolean
-handle_user_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_user_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
if (!read_settings (data, cfg, cfg->user_settings)) {
msg_err ("cannot read settings %s", data);
return TRUE;
}
gboolean
-handle_domain_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_domain_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
if (!read_settings (data, cfg, cfg->domain_settings)) {
msg_err ("cannot read settings %s", data);
/* Classifier */
gboolean
-handle_classifier_tokenizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_classifier_tokenizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct classifier_config *ccf = ctx->section_pointer;
}
gboolean
-handle_classifier_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_classifier_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct classifier_config *ccf = ctx->section_pointer;
gchar *val;
/* Statfile */
gboolean
-handle_statfile_normalizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_statfile_normalizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
msg_info ("normalizer option is now not available as rspamd always use internal normalizer for winnow (hyperbolic tanhent)");
return TRUE;
}
gboolean
-handle_statfile_binlog (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_statfile_binlog (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct statfile *st = ctx->section_pointer;
}
gboolean
-handle_statfile_binlog_rotate (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_statfile_binlog_rotate (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct statfile *st = ctx->section_pointer;
}
gboolean
-handle_statfile_binlog_master (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+handle_statfile_binlog_master (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
struct statfile *st = ctx->section_pointer;
if (st->binlog == NULL) {
/* Common handlers */
gboolean
-xml_handle_string (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_string (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
/* Simply assign pointer to pointer */
gchar **dest;
- dest = (char **)G_STRUCT_MEMBER_P (dest_struct, offset);
+ dest = (gchar **)G_STRUCT_MEMBER_P (dest_struct, offset);
*dest = memory_pool_strdup (cfg->cfg_pool, data);
return TRUE;
}
gboolean
-xml_handle_string_list (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_string_list (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
GList **dest;
gchar **tokens, **cur;
gboolean
-xml_handle_size (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_size (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
gsize *dest;
}
gboolean
-xml_handle_seconds (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_seconds (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
guint32 *dest;
}
gboolean
-xml_handle_boolean (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_boolean (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
gboolean *dest;
}
gboolean
-xml_handle_double (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_double (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
double *dest;
- char *err = NULL;
+ gchar *err = NULL;
dest = (double *)G_STRUCT_MEMBER_P (dest_struct, offset);
errno = 0;
}
gboolean
-xml_handle_int (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_int (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
- int *dest;
- char *err = NULL;
+ gint *dest;
+ gchar *err = NULL;
- dest = (int *)G_STRUCT_MEMBER_P (dest_struct, offset);
+ dest = (gint *)G_STRUCT_MEMBER_P (dest_struct, offset);
errno = 0;
*dest = strtol (data, &err, 10);
if (errno != 0 || (err != NULL && *err != 0)) {
}
gboolean
-xml_handle_uint32 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_uint32 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
- uint32_t *dest;
- char *err = NULL;
+ guint32 *dest;
+ gchar *err = NULL;
- dest = (uint32_t *)G_STRUCT_MEMBER_P (dest_struct, offset);
+ dest = (guint32 *)G_STRUCT_MEMBER_P (dest_struct, offset);
errno = 0;
*dest = strtoul (data, &err, 10);
if (errno != 0 || (err != NULL && *err != 0)) {
}
gboolean
-xml_handle_uint16 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset)
+xml_handle_uint16 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset)
{
- uint16_t *dest;
- char *err = NULL;
+ guint16 *dest;
+ gchar *err = NULL;
- dest = (uint16_t *)G_STRUCT_MEMBER_P (dest_struct, offset);
+ dest = (guint16 *)G_STRUCT_MEMBER_P (dest_struct, offset);
errno = 0;
*dest = strtoul (data, &err, 10);
if (errno != 0 || (err != NULL && *err != 0)) {
rspamd_xml_text (GMarkupParseContext *context, const gchar *text, gsize text_len, gpointer user_data, GError **error)
{
struct rspamd_xml_userdata *ud = user_data;
- char *val;
+ gchar *val;
struct config_file *cfg = ud->cfg;
/* Strip space symbols */
static gboolean
xml_dump_main (struct config_file *cfg, FILE *f)
{
- char *escaped_str;
+ gchar *escaped_str;
/* Print header comment */
- fprintf (f, "<!-- Main section -->" EOL);
+ rspamd_fprintf (f, "<!-- Main section -->" EOL);
escaped_str = g_markup_escape_text (cfg->temp_dir, -1);
- fprintf (f, "<tempdir>%s</tempdir>" EOL, escaped_str);
+ rspamd_fprintf (f, "<tempdir>%s</tempdir>" EOL, escaped_str);
g_free (escaped_str);
escaped_str = g_markup_escape_text (cfg->pid_file, -1);
- fprintf (f, "<pidfile>%s</pidfile>" EOL, escaped_str);
+
rspamd_fprintf (f, "<pidfile>%s</pidfile>" EOL, escaped_str);
g_free (escaped_str);
escaped_str = g_markup_escape_text (cfg->filters_str, -1);
- fprintf (f, "<filters>%s</filters>" EOL, escaped_str);
+ rspamd_fprintf (f, "<filters>%s</filters>" EOL, escaped_str);
g_free (escaped_str);
if (cfg->user_settings_str) {
escaped_str = g_markup_escape_text (cfg->user_settings_str, -1);
- fprintf (f, "<user_settings>%s</user_settings>" EOL, escaped_str);
+ rspamd_fprintf (f, "<user_settings>%s</user_settings>" EOL, escaped_str);
g_free (escaped_str);
}
if (cfg->domain_settings_str) {
escaped_str = g_markup_escape_text (cfg->domain_settings_str, -1);
- fprintf (f, "<domain_settings>%s</domain_settings>" EOL, escaped_str);
+ rspamd_fprintf (f, "<domain_settings>%s</domain_settings>" EOL, escaped_str);
g_free (escaped_str);
}
- fprintf (f, "<statfile_pool_size>%llu</statfile_pool_size>" EOL, (long long unsigned)cfg->max_statfile_size);
+ rspamd_fprintf (f, "<statfile_pool_size>%z</statfile_pool_size>" EOL, cfg->max_statfile_size);
if (cfg->checksum) {
escaped_str = g_markup_escape_text (cfg->checksum, -1);
- fprintf (f, "<checksum>%s</checksum>" EOL, escaped_str);
+ rspamd_fprintf (f, "<checksum>%s</checksum>" EOL, escaped_str);
g_free (escaped_str);
}
- fprintf (f, "<raw_mode>%s</raw_mode>" EOL, cfg->raw_mode ? "yes" : "no");
+ rspamd_fprintf (f, "<raw_mode>%s</raw_mode>" EOL, cfg->raw_mode ? "yes" : "no");
/* Print footer comment */
- fprintf (f, "<!-- End of main section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of main section -->" EOL EOL);
return TRUE;
}
xml_variable_callback (gpointer key, gpointer value, gpointer user_data)
{
FILE *f = user_data;
- char *escaped_key, *escaped_value;
+ gchar *escaped_key, *escaped_value;
escaped_key = g_markup_escape_text (key, -1);
escaped_value = g_markup_escape_text (value, -1);
- fprintf (f, "<variable name=\"%s\">%s</variable>" EOL, escaped_key, escaped_value);
+ rspamd_fprintf (f, "<variable name=\"%s\">%s</variable>" EOL, escaped_key, escaped_value);
g_free (escaped_key);
g_free (escaped_value);
}
xml_dump_variables (struct config_file *cfg, FILE *f)
{
/* Print header comment */
- fprintf (f, "<!-- Variables section -->" EOL);
+ rspamd_fprintf (f, "<!-- Variables section -->" EOL);
/* Iterate through variables */
g_hash_table_foreach (cfg->variables, xml_variable_callback, (gpointer)f);
/* Print footer comment */
- fprintf (f, "<!-- End of variables section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of variables section -->" EOL EOL);
return TRUE;
}
{
FILE *f = user_data;
struct expression *expr;
- char *escaped_key, *escaped_value;
+ gchar *escaped_key, *escaped_value;
expr = value;
escaped_key = g_markup_escape_text (key, -1);
escaped_value = g_markup_escape_text (expr->orig, -1);
- fprintf (f, "<composite name=\"%s\">%s</composite>" EOL, escaped_key, escaped_value);
+ rspamd_fprintf (f, "<composite name=\"%s\">%s</composite>" EOL, escaped_key, escaped_value);
g_free (escaped_key);
g_free (escaped_value);
}
xml_dump_composites (struct config_file *cfg, FILE *f)
{
/* Print header comment */
- fprintf (f, "<!-- Composites section -->" EOL);
+ rspamd_fprintf (f, "<!-- Composites section -->" EOL);
/* Iterate through variables */
g_hash_table_foreach (cfg->composite_symbols, xml_composite_callback, (gpointer)f);
/* Print footer comment */
- fprintf (f, "<!-- End of composites section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of composites section -->" EOL EOL);
return TRUE;
}
xml_worker_param_callback (gpointer key, gpointer value, gpointer user_data)
{
FILE *f = user_data;
- char *escaped_key, *escaped_value;
+ gchar *escaped_key, *escaped_value;
escaped_key = g_markup_escape_text (key, -1);
escaped_value = g_markup_escape_text (value, -1);
- fprintf (f, " <param name=\"%s\">%s</param>" EOL, escaped_key, escaped_value);
+
rspamd_fprintf (f, " <param name=\"%s\">%s</param>" EOL, escaped_key, escaped_value);
g_free (escaped_key);
g_free (escaped_value);
}
{
GList *cur;
struct worker_conf *wrk;
- char *escaped_str;
+ gchar *escaped_str;
/* Print header comment */
- fprintf (f, "<!-- Workers section -->" EOL);
+ rspamd_fprintf (f, "<!-- Workers section -->" EOL);
/* Iterate through list */
cur = g_list_first (cfg->workers);
while (cur) {
wrk = cur->data;
- fprintf (f, "<worker>" EOL);
+ rspamd_fprintf (f, "<worker>" EOL);
switch (wrk->type) {
case TYPE_WORKER:
- fprintf (f, " <type>normal</type>" EOL);
+ rspamd_fprintf (f, " <type>normal</type>" EOL);
break;
case TYPE_CONTROLLER:
- fprintf (f, " <type>controller</type>" EOL);
+ rspamd_fprintf (f, " <type>controller</type>" EOL);
break;
case TYPE_FUZZY:
- fprintf (f, " <type>fuzzy</type>" EOL);
+ rspamd_fprintf (f, " <type>fuzzy</type>" EOL);
break;
case TYPE_LMTP:
- fprintf (f, " <type>lmtp</type>" EOL);
+ rspamd_fprintf (f, " <type>lmtp</type>" EOL);
break;
case TYPE_SMTP:
- fprintf (f, " <type>smtp</type>" EOL);
+ rspamd_fprintf (f, " <type>smtp</type>" EOL);
break;
}
escaped_str = g_markup_escape_text (wrk->bind_host, -1);
- fprintf (f, " <bind_socket>%s</bind_socket>" EOL, escaped_str);
+ rspamd_fprintf (f, " <bind_socket>%s</bind_socket>" EOL, escaped_str);
g_free (escaped_str);
- fprintf (f, " <count>%ud</count>" EOL, wrk->count);
- fprintf (f, " <maxfiles>%ud</maxfiles>" EOL, wrk->rlimit_nofile);
- fprintf (f, " <maxcore>%ud</maxcore>" EOL, wrk->rlimit_maxcore);
+ rspamd_fprintf (f, " <count>%ud</count>" EOL, wrk->count);
+ rspamd_fprintf (f, " <maxfiles>%ud</maxfiles>" EOL, wrk->rlimit_nofile);
+ rspamd_fprintf (f, " <maxcore>%ud</maxcore>" EOL, wrk->rlimit_maxcore);
/* Now dump other attrs */
- fprintf (f, "<!-- Other params -->" EOL);
+ rspamd_fprintf (f, "<!-- Other params -->" EOL);
g_hash_table_foreach (wrk->params, xml_worker_param_callback, f);
- fprintf (f, "</worker>" EOL);
+ rspamd_fprintf (f, "</worker>" EOL);
cur = g_list_next (cur);
}
/* Print footer comment */
- fprintf (f, "<!-- End of workers section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of workers section -->" EOL EOL);
return TRUE;
}
xml_module_callback (gpointer key, gpointer value, gpointer user_data)
{
FILE *f = user_data;
- char *escaped_key, *escaped_value;
+ gchar *escaped_key, *escaped_value;
GList *cur;
struct module_opt *opt;
escaped_key = g_markup_escape_text (key, -1);
- fprintf (f, "<!-- %s -->" EOL, escaped_key);
- fprintf (f, "<module name=\"%s\">" EOL, escaped_key);
+ rspamd_fprintf (f, "<!-- %s -->" EOL, escaped_key);
+ rspamd_fprintf (f, "<module name=\"%s\">" EOL, escaped_key);
g_free (escaped_key);
cur = g_list_first (value);
opt = cur->data;
escaped_key = g_markup_escape_text (opt->param, -1);
escaped_value = g_markup_escape_text (opt->value, -1);
- fprintf (f, " <option name=\"%s\">%s</option>" EOL, escaped_key, escaped_value);
+ rspamd_fprintf (f, " <option name=\"%s\">%s</option>" EOL, escaped_key, escaped_value);
g_free (escaped_key);
g_free (escaped_value);
cur = g_list_next (cur);
}
- fprintf (f, "</module>" EOL EOL);
+ rspamd_fprintf (f, "</module>" EOL EOL);
}
static gboolean
xml_dump_modules (struct config_file *cfg, FILE *f)
{
/* Print header comment */
- fprintf (f, "<!-- Modules section -->" EOL);
+ rspamd_fprintf (f, "<!-- Modules section -->" EOL);
/* Iterate through variables */
g_hash_table_foreach (cfg->modules_opts, xml_module_callback, (gpointer)f);
/* Print footer comment */
- fprintf (f, "<!-- End of modules section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of modules section -->" EOL EOL);
return TRUE;
}
xml_classifier_callback (gpointer key, gpointer value, gpointer user_data)
{
FILE *f = user_data;
- char *escaped_key, *escaped_value;
+ gchar *escaped_key, *escaped_value;
escaped_key = g_markup_escape_text (key, -1);
escaped_value = g_markup_escape_text (value, -1);
- fprintf (f, " <option name=\"%s\">%s</option>" EOL, escaped_key, escaped_value);
+ rspamd_fprintf (f, " <option name=\"%s\">%s</option>" EOL, escaped_key, escaped_value);
g_free (escaped_key);
g_free (escaped_value);
}
struct statfile *st;
/* Print header comment */
- fprintf (f, "<!-- Classifiers section -->" EOL);
+ rspamd_fprintf (f, "<!-- Classifiers section -->" EOL);
/* Iterate through classifiers */
cur = g_list_first (cfg->classifiers);
while (cur) {
ccf = cur->data;
- fprintf (f, "<classifier type=\"%s\">" EOL, ccf->classifier->name);
- fprintf (f, " <tokenizer>%s</tokenizer>" EOL, ccf->tokenizer->name);
- fprintf (f, " <metric>%s</metric>" EOL, ccf->metric);
+ rspamd_fprintf (f, "<classifier type=\"%s\">" EOL, ccf->classifier->name);
+ rspamd_fprintf (f, " <tokenizer>%s</tokenizer>" EOL, ccf->tokenizer->name);
+ rspamd_fprintf (f, " <metric>%s</metric>" EOL, ccf->metric);
g_hash_table_foreach (ccf->opts, xml_classifier_callback, f);
/* Statfiles */
cur_st = g_list_first (ccf->statfiles);
while (cur_st) {
st = cur_st->data;
- fprintf (f, " <statfile>" EOL);
-
fprintf (f, " <symbol>%s</symbol>" EOL " <size>%lu</size>" EOL " <path>%s</path>" EOL,
- st->symbol, (long unsigned)st->size, st->path);
- fprintf (f, " <normalizer>%s</normalizer>" EOL, st->normalizer_str);
+ rspamd_fprintf (f, " <statfile>" EOL);
+
rspamd_fprintf (f, " <symbol>%s</symbol>" EOL " <size>%z</size>" EOL " <path>%s</path>" EOL,
+ st->symbol, st->size, st->path);
+ rspamd_fprintf (f, " <normalizer>%s</normalizer>" EOL, st->normalizer_str);
/* Binlog */
if (st->binlog) {
if (st->binlog->affinity == AFFINITY_MASTER) {
- fprintf (f, " <binlog>master</binlog>" EOL);
+ rspamd_fprintf (f, " <binlog>master</binlog>" EOL);
}
else if (st->binlog->affinity == AFFINITY_SLAVE) {
- fprintf (f, " <binlog>slave</binlog>" EOL);
- fprintf (f, " <binlog_master>%s:%d</binlog_master>" EOL,
- inet_ntoa (st->binlog->master_addr), ntohs (st->binlog->master_port));
+ rspamd_fprintf (f, " <binlog>slave</binlog>" EOL);
+ rspamd_fprintf (f, " <binlog_master>%s:%d</binlog_master>" EOL,
+ inet_ntoa (st->binlog->master_addr), (gint)ntohs (st->binlog->master_port));
}
- fprintf (f, " <binlog_rotate>%lu</binlog_rotate>" EOL, (long unsigned)st->binlog->rotate_time);
+ rspamd_fprintf (f, " <binlog_rotate>%T</binlog_rotate>" EOL, st->binlog->rotate_time);
}
- fprintf (f, " </statfile>" EOL);
+ rspamd_fprintf (f, " </statfile>" EOL);
cur_st = g_list_next (cur_st);
}
- fprintf (f, "</classifier>" EOL);
+ rspamd_fprintf (f, "</classifier>" EOL);
cur = g_list_next (cur);
}
/* Print footer comment */
- fprintf (f, "<!-- End of classifiers section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of classifiers section -->" EOL EOL);
return TRUE;
gchar *escaped_value;
/* Print header comment */
- fprintf (f, "<!-- Logging section -->" EOL);
- fprintf (f, "<logging>" EOL);
+ rspamd_fprintf (f, "<!-- Logging section -->" EOL);
+ rspamd_fprintf (f, "<logging>" EOL);
/* Level */
if (cfg->log_level < G_LOG_LEVEL_WARNING) {
- fprintf (f, " <level>error</level>" EOL);
+ rspamd_fprintf (f, " <level>error</level>" EOL);
}
else if (cfg->log_level < G_LOG_LEVEL_MESSAGE) {
- fprintf (f, " <level>warning</level>" EOL);
+ rspamd_fprintf (f, " <level>warning</level>" EOL);
}
else if (cfg->log_level < G_LOG_LEVEL_DEBUG) {
- fprintf (f, " <level>info</level>" EOL);
+ rspamd_fprintf (f, " <level>info</level>" EOL);
}
else {
- fprintf (f, " <level>debug</level>" EOL);
+ rspamd_fprintf (f, " <level>debug</level>" EOL);
}
/* Other options */
- fprintf (f, " <log_urls>%s</log_urls>" EOL, cfg->log_urls ? "yes" : "no");
+ rspamd_fprintf (f, " <log_urls>%s</log_urls>" EOL, cfg->log_urls ? "yes" : "no");
if (cfg->log_buf_size != 0) {
- fprintf (f, " <log_buffer>%ud</log_buffer>" EOL, (unsigned)cfg->log_buf_size);
+ rspamd_fprintf (f, " <log_buffer>%ud</log_buffer>" EOL, (guint)cfg->log_buf_size);
}
if (cfg->debug_ip_map != NULL) {
escaped_value = g_markup_escape_text (cfg->debug_ip_map, -1);
- fprintf (f, " <debug_ip>%s</debug_ip>" EOL, escaped_value);
+ rspamd_fprintf (f, " <debug_ip>%s</debug_ip>" EOL, escaped_value);
g_free (escaped_value);
}
/* Handle type */
if (cfg->log_type == RSPAMD_LOG_FILE) {
escaped_value = g_markup_escape_text (cfg->log_file, -1);
- fprintf (f, " <type filename=\"%s\">file</type>" EOL, escaped_value);
+ rspamd_fprintf (f, " <type filename=\"%s\">file</type>" EOL, escaped_value);
g_free (escaped_value);
}
else if (cfg->log_type == RSPAMD_LOG_CONSOLE) {
- fprintf (f, " <type>console</type>" EOL);
+ rspamd_fprintf (f, " <type>console</type>" EOL);
}
else if (cfg->log_type == RSPAMD_LOG_SYSLOG) {
escaped_value = NULL;
escaped_value = "LOG_LOCAL7";
break;
}
- fprintf (f, " <type facility=\"%s\">syslog</type>" EOL, escaped_value);
+ rspamd_fprintf (f, " <type facility=\"%s\">syslog</type>" EOL, escaped_value);
}
- fprintf (f, "</logging>" EOL);
+ rspamd_fprintf (f, "</logging>" EOL);
/* Print footer comment */
- fprintf (f, "<!-- End of logging section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of logging section -->" EOL EOL);
return TRUE;
}
struct script_module *module;
/* Print header comment */
- fprintf (f, "<!-- Modules section -->" EOL);
- fprintf (f, "<modules>" EOL);
+ rspamd_fprintf (f, "<!-- Modules section -->" EOL);
+ rspamd_fprintf (f, "<modules>" EOL);
cur = cfg->script_modules;
while (cur) {
module = cur->data;
escaped_value = g_markup_escape_text (module->path, -1);
- fprintf (f, " <path>%s</path>" EOL, escaped_value);
+
rspamd_fprintf (f, " <path>%s</path>" EOL, escaped_value);
g_free (escaped_value);
cur = g_list_next (cur);
}
- fprintf (f, "</modules>" EOL);
+ rspamd_fprintf (f, "</modules>" EOL);
/* Print footer comment */
- fprintf (f, "<!-- End of modules section -->" EOL EOL);
+ rspamd_fprintf (f, "<!-- End of modules section -->" EOL EOL);
return TRUE;
}
#define CHECK_RES do { if (!res) { fclose (f); return FALSE; } } while (0)
gboolean
-xml_dump_config (struct config_file *cfg, const char *filename)
+xml_dump_config (struct config_file *cfg, const gchar *filename)
{
FILE *f;
gboolean res = FALSE;
}
/* Header */
- fprintf (f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" EOL "<rspamd>" EOL);
+ rspamd_fprintf (f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" EOL "<rspamd>" EOL);
/* Now dump all parts of config */
res = xml_dump_main (cfg, f);
CHECK_RES;
res = xml_dump_modules_paths (cfg, f);
CHECK_RES;
/* Footer */
- fprintf (f, "</rspamd>" EOL);
+ rspamd_fprintf (f, "</rspamd>" EOL);
fclose (f);
return TRUE;
};
/* Text is NULL terminated here */
-typedef gboolean (*element_handler_func) (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+typedef gboolean (*element_handler_func) (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
/* Callbacks */
/* Handlers */
/* Basic xml parsing functions */
-gboolean xml_handle_string (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean xml_handle_string_list (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean xml_handle_string (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean xml_handle_string_list (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
/* Numeric params */
-gboolean xml_handle_size (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean xml_handle_double (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean xml_handle_seconds (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean xml_handle_int (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean xml_handle_uint32 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean xml_handle_uint16 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean xml_handle_size (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean xml_handle_double (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean xml_handle_seconds (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean xml_handle_int (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean xml_handle_uint32 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean xml_handle_uint16 (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
/* Flags */
-gboolean xml_handle_boolean (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean xml_handle_boolean (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
/* Specific params */
-gboolean worker_handle_param (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean worker_handle_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean worker_handle_bind (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean worker_handle_param (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean worker_handle_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean worker_handle_bind (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_metric_symbol (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_metric_action (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_metric_symbol (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_metric_action (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_module_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_module_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_log_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_log_level (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_log_type (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_log_level (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_lua (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_lua (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_module_path (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_module_path (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_variable (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_composite (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_variable (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_composite (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_view_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_view_client_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_view_from (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_view_rcpt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_view_symbols (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_view_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_view_client_ip (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_view_from (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_view_rcpt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_view_symbols (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_user_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_domain_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_user_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_domain_settings (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_classifier_tokenizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_classifier_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_classifier_tokenizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_classifier_opt (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
-gboolean handle_statfile_normalizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_statfile_binlog (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_statfile_binlog_rotate (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
-gboolean handle_statfile_binlog_master (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, int offset);
+gboolean handle_statfile_normalizer (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_statfile_binlog (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_statfile_binlog_rotate (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
+gboolean handle_statfile_binlog_master (struct config_file *cfg, struct rspamd_xml_userdata *ctx, GHashTable *attrs, gchar *data, gpointer user_data, gpointer dest_struct, gint offset);
/* Dumper functions */
-gboolean xml_dump_config (struct config_file *cfg, const char *filename);
+gboolean xml_dump_config (struct config_file *cfg, const gchar *filename);
#endif
};
struct controller_command {
- char *command;
+ gchar *command;
gboolean privilleged;
enum command_type type;
};
struct custom_controller_command {
- const char *command;
+ const gchar *command;
gboolean privilleged;
gboolean require_message;
controller_func_t handler;
static GCompletion *comp;
static time_t start_time;
-static char greetingbuf[1024];
+static gchar greetingbuf[1024];
static sig_atomic_t wanna_die = 0;
extern rspamd_hash_t *counters;
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t *info, void *unused)
#endif
{
struct timeval tv;
}
static void
-sigusr_handler (int fd, short what, void *arg)
+sigusr_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
g_free (session);
}
-static int
+static gint
check_auth (struct controller_command *cmd, struct controller_session *session)
{
- char out_buf[128];
- int r;
+ gchar out_buf[128];
+ gint r;
if (cmd->privilleged && !session->authorized) {
r = rspamd_snprintf (out_buf, sizeof (out_buf), "not authorized" CRLF);
{
struct controller_session *session = data;
struct counter_data *cd = value;
- char *name = key;
- char out_buf[128];
- int r;
+ gchar *name = key;
+ gchar out_buf[128];
+ gint r;
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "%s: %ul" CRLF, name, (unsigned long int)cd->value);
+ r = rspamd_snprintf (out_buf, sizeof (out_buf), "%s: %uD" CRLF, name, (guint32)cd->value);
if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, TRUE, FALSE)) {
msg_warn ("cannot write to socket");
}
}
static gboolean
-write_whole_statfile (struct controller_session *session, char *symbol, struct classifier_config *ccf)
+write_whole_statfile (struct controller_session *session, gchar *symbol, struct classifier_config *ccf)
{
stat_file_t *statfile;
struct statfile *st;
- char out_buf[BUFSIZ];
- int i;
- uint64_t rev, ti, len, pos;
- char *out;
+ gchar out_buf[BUFSIZ];
+ gint i;
+ guint64 rev, ti, len, pos;
+ gchar *out;
struct rspamd_binlog_element log_elt;
struct stat_file_block *stat_elt;
}
static gboolean
-process_sync_command (struct controller_session *session, char **args)
+process_sync_command (struct controller_session *session, gchar **args)
{
- char out_buf[BUFSIZ], *arg, *err_str, *symbol;
- int r;
- uint64_t rev, time;
+ gchar out_buf[BUFSIZ], *arg, *err_str, *symbol;
+ gint r;
+ guint64 rev, time;
struct statfile *st;
struct classifier_config *ccf;
GList *cur;
}
while (binlog_sync (binlog, rev, &time, &data)) {
- r = rspamd_snprintf (out_buf, sizeof (out_buf), "%ul %ul %ul" CRLF, (long unsigned)rev, (long unsigned)time, (long unsigned)data->len);
+ 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);
static gboolean
process_stat_command (struct controller_session *session)
{
- char out_buf[BUFSIZ], *numbuf;
- int r;
- uint64_t used, total, rev;
+ gchar out_buf[BUFSIZ], *numbuf;
+ gint r;
+ guint64 used, total, rev;
time_t ti;
memory_pool_stat_t mem_st;
struct classifier_config *ccf;
r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Messages learned: %ud" CRLF, session->worker->srv->stat->messages_learned);
r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Connections count: %ud" CRLF, session->worker->srv->stat->connections_count);
r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Control connections count: %ud" CRLF, session->worker->srv->stat->control_connections_count);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Pools allocated: %l" CRLF, (long int)mem_st.pools_allocated);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Pools freed: %l" CRLF, (long int)mem_st.pools_freed);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Bytes allocated: %l" CRLF, (long int)mem_st.bytes_allocated);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Memory chunks allocated: %l" CRLF, (long int)mem_st.chunks_allocated);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Shared chunks allocated: %l" CRLF, (long int)mem_st.shared_chunks_allocated);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Chunks freed: %l" CRLF, (long int)mem_st.chunks_freed);
- r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Oversized chunks: %l" CRLF, (long int)mem_st.oversized_chunks);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Pools allocated: %z" CRLF, mem_st.pools_allocated);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Pools freed: %z" CRLF, mem_st.pools_freed);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Bytes allocated: %z" CRLF, mem_st.bytes_allocated);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Memory chunks allocated: %z" CRLF, mem_st.chunks_allocated);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Shared chunks allocated: %z" CRLF, mem_st.shared_chunks_allocated);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Chunks freed: %z" CRLF, mem_st.chunks_freed);
+ r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Oversized chunks: %z" CRLF, mem_st.oversized_chunks);
r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Fuzzy hashes stored: %ud" CRLF, session->worker->srv->stat->fuzzy_hashes);
r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r, "Fuzzy hashes expired: %ud" CRLF, session->worker->srv->stat->fuzzy_hashes_expired);
/* Now write statistics for each statfile */
used = statfile_get_used_blocks (statfile);
total = statfile_get_total_blocks (statfile);
statfile_get_revision (statfile, &rev, &ti);
- if (total != (uint64_t)-1 && used != (uint64_t)-1) {
+ if (total != (guint64)-1 && used != (guint64)-1) {
numbuf = g_format_size_for_display (st->size);
r += rspamd_snprintf (out_buf + r, sizeof (out_buf) - r,
- "Statfile: %s (version %ul); length: %s; free blocks: %ul; total blocks: %ul; free: %.2f%%" CRLF,
- st->symbol, (long unsigned)rev, numbuf,
- (long unsigned)(total - used), (long unsigned)total,
+ "Statfile: %s (version %uL); length: %s; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
+ st->symbol, rev, numbuf,
+ (total - used), total,
(double)((double)(total - used) / (double)total) * 100.);
g_free (numbuf);
}
}
static gboolean
-process_command (struct controller_command *cmd, char **cmd_args, struct controller_session *session)
+process_command (struct controller_command *cmd, gchar **cmd_args, struct controller_session *session)
{
- char out_buf[BUFSIZ], *arg, *err_str;
- int r = 0, days, hours, minutes;
+ gchar out_buf[BUFSIZ], *arg, *err_str;
+ gint r = 0, days, hours, minutes;
time_t uptime;
- unsigned long size = 0;
+ guint32 size = 0;
struct classifier_config *cl;
- char *password = g_hash_table_lookup (session->worker->cf->params, "password");
+ gchar *password = g_hash_table_lookup (session->worker->cf->params, "password");
switch (cmd->type) {
case COMMAND_PASSWORD:
}
/* 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, (int)uptime, (int)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" : " ", (int)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 (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
return FALSE;
}
static gboolean
-process_custom_command (char *line, char **cmd_args, struct controller_session *session)
+process_custom_command (gchar *line, gchar **cmd_args, struct controller_session *session)
{
GList *cur;
struct custom_controller_command *cmd;
struct classifier_ctx *cls_ctx;
stat_file_t *statfile;
struct statfile *st;
- int len, i, r;
- char *s, **params, *cmd, out_buf[128];
+ gint len, i, r;
+ gchar *s, **params, *cmd, out_buf[128];
struct worker_task *task;
struct mime_text_part *part;
GList *comp_list, *cur = NULL;
}
static void
-accept_socket (int fd, short what, void *arg)
+accept_socket (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
struct sockaddr_storage ss;
struct controller_session *new_session;
struct timeval *io_tv;
socklen_t addrlen = sizeof (ss);
- int nfd;
+ gint nfd;
if ((nfd = accept_from_socket (fd, (struct sockaddr *)&ss, &addrlen)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
start_controller (struct rspamd_worker *worker)
{
struct sigaction signals;
- int i;
+ gint i;
GList *comp_list = NULL;
- char *hostbuf;
- long int hostmax;
+ gchar *hostbuf;
+ gsize hostmax;
worker->srv->pid = getpid ();
event_init ();
}
void
-register_custom_controller_command (const char *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;
#define DNS_K_TEA_CYCLES 32
#define DNS_K_TEA_MAGIC 0x9E3779B9U
-static void dns_retransmit_handler (int fd, short what, void *arg);
+static void dns_retransmit_handler (gint fd, short what, void *arg);
static void
-dns_k_tea_init(struct dns_k_tea *tea, uint32_t key[], unsigned cycles)
+dns_k_tea_init(struct dns_k_tea *tea, guint32 key[], guint cycles)
{
memcpy(tea->key, key, sizeof tea->key);
static void
-dns_k_tea_encrypt (struct dns_k_tea *tea, uint32_t v[], uint32_t *w)
+dns_k_tea_encrypt (struct dns_k_tea *tea, guint32 v[], guint32 *w)
{
guint32 y, z, sum, n;
-static inline unsigned int
-dns_k_permutor_powof (unsigned int n)
+static inline guint
+dns_k_permutor_powof (guint n)
{
- unsigned int m, i = 0;
+ guint m, i = 0;
for (m = 1; m < n; m <<= 1, i++);
} /* dns_k_permutor_powof() */
static void
-dns_k_permutor_init (struct dns_k_permutor *p, unsigned low, unsigned high)
+dns_k_permutor_init (struct dns_k_permutor *p, guint low, guint high)
{
- uint32_t key[DNS_K_TEA_KEY_SIZE / sizeof (uint32_t)];
- unsigned width, i;
+ guint32 key[DNS_K_TEA_KEY_SIZE / sizeof (guint32)];
+ guint width, i;
p->stepi = 0;
} /* dns_k_permutor_init() */
-static unsigned
-dns_k_permutor_F (struct dns_k_permutor *p, unsigned k, unsigned x)
+static guint
+dns_k_permutor_F (struct dns_k_permutor *p, guint k, guint x)
{
- uint32_t in[DNS_K_TEA_BLOCK_SIZE / sizeof (uint32_t)], out[DNS_K_TEA_BLOCK_SIZE / sizeof (uint32_t)];
+ guint32 in[DNS_K_TEA_BLOCK_SIZE / sizeof (guint32)], out[DNS_K_TEA_BLOCK_SIZE / sizeof (guint32)];
memset(in, '\0', sizeof in);
} /* dns_k_permutor_F() */
-static unsigned
-dns_k_permutor_E (struct dns_k_permutor *p, unsigned n)
+static guint
+dns_k_permutor_E (struct dns_k_permutor *p, guint n)
{
- unsigned l[2], r[2];
- unsigned i;
+ guint l[2], r[2];
+ guint i;
i = 0;
l[i] = p->mask & (n >> p->shift);
} /* dns_k_permutor_E() */
-static unsigned
-dns_k_permutor_D (struct dns_k_permutor *p, unsigned n)
+static guint
+dns_k_permutor_D (struct dns_k_permutor *p, guint n)
{
- unsigned l[2], r[2];
- unsigned i;
+ guint l[2], r[2];
+ guint i;
i = p->rounds - 1;
l[i % 2] = p->mask & (n >> p->shift);
} /* dns_k_permutor_D() */
-static unsigned
+static guint
dns_k_permutor_step(struct dns_k_permutor *p)
{
- unsigned n;
+ guint n;
do {
n = dns_k_permutor_E(p, p->stepi++);
* Simple permutation box. Useful for shuffling rrsets from an iterator.
* Uses AES s-box to provide good diffusion.
*/
-static unsigned short
-dns_k_shuffle16 (unsigned short n, unsigned s)
+static guint16
+dns_k_shuffle16 (guint16 n, guint s)
{
- static const unsigned char sbox[256] =
+ static const guint8 sbox[256] =
{ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
- unsigned char a, b;
- unsigned i;
+ guchar a, b;
+ guint i;
a = 0xff & (n >> 0);
b = 0xff & (n >> 8);
}
static void
-format_dns_name (struct rspamd_dns_request *req, const char *name, guint namelen)
+format_dns_name (struct rspamd_dns_request *req, const gchar *name, guint namelen)
{
guint8 *pos = req->packet + req->pos, *end, *dot, *begin;
guint remain = req->packet_len - req->pos - 5, label_len;
static void
make_ptr_req (struct rspamd_dns_request *req, struct in_addr addr)
{
- char ipbuf[sizeof("255.255.255.255.in-addr.arpa")];
+ gchar ipbuf[sizeof("255.255.255.255.in-addr.arpa")];
guint32 a = ntohl (addr.s_addr), r;
guint16 *p;
r = rspamd_snprintf (ipbuf, sizeof(ipbuf), "%d.%d.%d.%d.in-addr.arpa",
- (int)(guint8)((a ) & 0xff),
- (int)(guint8)((a>>8 ) & 0xff),
- (int)(guint8)((a>>16) & 0xff),
- (int)(guint8)((a>>24) & 0xff));
+ (gint)(guint8)((a ) & 0xff),
+ (gint)(guint8)((a>>8 ) & 0xff),
+ (gint)(guint8)((a>>16) & 0xff),
+ (gint)(guint8)((a>>24) & 0xff));
allocate_packet (req, r);
make_dns_header (req);
}
static void
-make_a_req (struct rspamd_dns_request *req, const char *name)
+make_a_req (struct rspamd_dns_request *req, const gchar *name)
{
guint16 *p;
}
static void
-make_txt_req (struct rspamd_dns_request *req, const char *name)
+make_txt_req (struct rspamd_dns_request *req, const gchar *name)
{
guint16 *p;
}
static void
-make_mx_req (struct rspamd_dns_request *req, const char *name)
+make_mx_req (struct rspamd_dns_request *req, const gchar *name)
{
guint16 *p;
}
static void
-make_srv_req (struct rspamd_dns_request *req, const char *service, const char *proto, const char *name)
+make_srv_req (struct rspamd_dns_request *req, const gchar *service, const gchar *proto, const gchar *name)
{
guint16 *p;
guint len;
}
static void
-make_spf_req (struct rspamd_dns_request *req, const char *name)
+make_spf_req (struct rspamd_dns_request *req, const gchar *name)
{
guint16 *p;
req->requested_name = name;
}
-static int
+static gint
send_dns_request (struct rspamd_dns_request *req)
{
gint r;
}
static guint8 *
-dns_request_reply_cmp (struct rspamd_dns_request *req, guint8 *in, int len)
+dns_request_reply_cmp (struct rspamd_dns_request *req, guint8 *in, gint len)
{
guint8 *p, *c, *l1, *l2;
guint16 len1, len2;
#define MAX_RECURSION_LEVEL 10
static gboolean
-dns_parse_labels (guint8 *in, char **target, guint8 **pos, struct rspamd_dns_reply *rep, int *remain, gboolean make_name)
+dns_parse_labels (guint8 *in, gchar **target, guint8 **pos, struct rspamd_dns_reply *rep, gint *remain, gboolean make_name)
{
guint16 namelen = 0;
guint8 *p = *pos, *begin = *pos, *l, *t, *end = *pos + *remain;
#define GET32(x) do {if (*remain < sizeof (guint32)) {goto err;} memcpy (&(x), p, sizeof (guint32)); (x) = ntohl ((x)); p += sizeof (guint32); *remain -= sizeof (guint32); } while(0)
static gint
-dns_parse_rr (guint8 *in, union rspamd_reply_element *elt, guint8 **pos, struct rspamd_dns_reply *rep, int *remain)
+dns_parse_rr (guint8 *in, union rspamd_reply_element *elt, guint8 **pos, struct rspamd_dns_reply *rep, gint *remain)
{
guint8 *p = *pos, parts;
guint16 type, datalen, txtlen, copied;
return 0;
err:
- msg_info ("incomplete RR, only %d bytes remain, packet length %d", (int)*remain, (int)(*pos - in));
+ msg_info ("incomplete RR, only %d bytes remain, packet length %d", (gint)*remain, (gint)(*pos - in));
return -1;
}
static struct rspamd_dns_reply *
-dns_parse_reply (guint8 *in, int r, struct rspamd_dns_resolver *resolver, struct rspamd_dns_request **req_out)
+dns_parse_reply (guint8 *in, gint r, struct rspamd_dns_resolver *resolver, struct rspamd_dns_request **req_out)
{
struct dns_header *header = (struct dns_header *)in;
struct rspamd_dns_request *req;
struct rspamd_dns_reply *rep;
union rspamd_reply_element *elt;
guint8 *pos;
- int i, t;
+ gint i, t;
/* First check header fields */
if (header->qr == 0) {
}
static void
-dns_read_cb (int fd, short what, void *arg)
+dns_read_cb (gint fd, short what, void *arg)
{
struct rspamd_dns_resolver *resolver = arg;
struct rspamd_dns_request *req = NULL;
- int r;
+ gint r;
struct rspamd_dns_reply *rep;
guint8 in[UDP_PACKET_SIZE];
}
static void
-dns_timer_cb (int fd, short what, void *arg)
+dns_timer_cb (gint fd, short what, void *arg)
{
struct rspamd_dns_request *req = arg;
struct rspamd_dns_reply *rep;
- int r;
+ gint r;
/* Retransmit dns request */
req->retransmits ++;
}
static void
-dns_retransmit_handler (int fd, short what, void *arg)
+dns_retransmit_handler (gint fd, short what, void *arg)
{
struct rspamd_dns_request *req = arg;
struct rspamd_dns_reply *rep;
va_list args;
struct rspamd_dns_request *req;
struct in_addr addr;
- const char *name, *service, *proto;
+ const gchar *name, *service, *proto;
gint r;
req = memory_pool_alloc (pool, sizeof (struct rspamd_dns_request));
make_ptr_req (req, addr);
break;
case DNS_REQUEST_MX:
- name = va_arg (args, const char *);
+ name = va_arg (args, const gchar *);
make_mx_req (req, name);
break;
case DNS_REQUEST_A:
- name = va_arg (args, const char *);
+ name = va_arg (args, const gchar *);
make_a_req (req, name);
break;
case DNS_REQUEST_TXT:
- name = va_arg (args, const char *);
+ name = va_arg (args, const gchar *);
make_txt_req (req, name);
break;
case DNS_REQUEST_SPF:
- name = va_arg (args, const char *);
+ name = va_arg (args, const gchar *);
make_spf_req (req, name);
break;
case DNS_REQUEST_SRV:
- service = va_arg (args, const char *);
- proto = va_arg (args, const char *);
- name = va_arg (args, const char *);
+ service = va_arg (args, const gchar *);
+ proto = va_arg (args, const gchar *);
+ name = va_arg (args, const gchar *);
make_srv_req (req, service, proto, name);
break;
}
parse_resolv_conf (struct rspamd_dns_resolver *resolver)
{
FILE *r;
- char buf[BUFSIZ], *p;
+ gchar buf[BUFSIZ], *p;
struct rspamd_dns_server *new;
struct in_addr addr;
{
GList *cur;
struct rspamd_dns_resolver *new;
- char *begin, *p;
- int priority, i;
+ gchar *begin, *p;
+ gint priority, i;
struct rspamd_dns_server *serv;
new = memory_pool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_dns_resolver));
return new;
}
-static char dns_rcodes[16][16] = {
+static gchar dns_rcodes[16][16] = {
[DNS_RC_NOERROR] = "NOERROR",
[DNS_RC_FORMERR] = "FORMERR",
[DNS_RC_SERVFAIL] = "SERVFAIL",
[DNS_RC_NOTZONE] = "NOTZONE",
};
-const char *
+const gchar *
dns_strerror (enum dns_rcode rcode)
{
rcode &= 0xf;
- static char numbuf[16];
+ static gchar numbuf[16];
if ('\0' == dns_rcodes[rcode][0]) {
- rspamd_snprintf (numbuf, sizeof (numbuf), "UNKNOWN: %d", (int)rcode);
+ rspamd_snprintf (numbuf, sizeof (numbuf), "UNKNOWN: %d", (gint)rcode);
return numbuf;
}
return dns_rcodes[rcode];
}
-static char dns_types[6][16] = {
+static gchar dns_types[6][16] = {
[DNS_REQUEST_A] = "A request",
[DNS_REQUEST_PTR] = "PTR request",
[DNS_REQUEST_MX] = "MX request",
[DNS_REQUEST_SPF] = "SPF request"
};
-const char *
+const gchar *
dns_strtype (enum rspamd_request_type type)
{
return dns_types[type];
struct rspamd_dns_server {
struct upstream up; /**< upstream structure */
struct in_addr addr; /**< address of DNS server */
- char *name; /**< name of DNS server */
- int sock; /**< persistent socket */
+ gchar *name; /**< name of DNS server */
+ gint sock; /**< persistent socket */
struct event ev;
};
#define DNS_K_TEA_KEY_SIZE 16
struct dns_k_tea {
- uint32_t key[DNS_K_TEA_KEY_SIZE / sizeof (uint32_t)];
- unsigned cycles;
+ guint32 key[DNS_K_TEA_KEY_SIZE / sizeof (guint32)];
+ guint cycles;
}; /* struct dns_k_tea */
struct dns_k_permutor {
- unsigned stepi, length, limit;
- unsigned shift, mask, rounds;
+ guint stepi, length, limit;
+ guint shift, mask, rounds;
struct dns_k_tea tea;
};
struct rspamd_async_session *session;
struct rspamd_dns_reply *reply;
guint8 *packet;
- const char *requested_name;
+ const gchar *requested_name;
off_t pos;
guint packet_len;
- int sock;
+ gint sock;
enum rspamd_request_type type;
time_t time;
};
/* Internal DNS structs */
struct dns_header {
- unsigned qid:16;
+ guint qid:16;
#if __BYTE_ORDER == BIG_ENDIAN
- unsigned qr:1;
- unsigned opcode:4;
- unsigned aa:1;
- unsigned tc:1;
- unsigned rd:1;
-
- unsigned ra:1;
- unsigned unused:3;
- unsigned rcode:4;
+ guint qr:1;
+ guint opcode:4;
+ guint aa:1;
+ guint tc:1;
+ guint rd:1;
+
+ guint ra:1;
+ guint unused:3;
+ guint rcode:4;
#else
- unsigned rd:1;
- unsigned tc:1;
- unsigned aa:1;
- unsigned opcode:4;
- unsigned qr:1;
-
- unsigned rcode:4;
- unsigned unused:3;
- unsigned ra:1;
+ guint rd:1;
+ guint tc:1;
+ guint aa:1;
+ guint opcode:4;
+ guint qr:1;
+
+ guint rcode:4;
+ guint unused:3;
+ guint ra:1;
#endif
- unsigned qdcount:16;
- unsigned ancount:16;
- unsigned nscount:16;
- unsigned arcount:16;
+ guint qdcount:16;
+ guint ancount:16;
+ guint nscount:16;
+ guint arcount:16;
};
enum dns_section {
}; /* enum dns_class */
struct dns_query {
- char *qname;
- unsigned qtype:16;
- unsigned qclass:16;
+ gchar *qname;
+ guint qtype:16;
+ guint qclass:16;
};
/* Rspamd DNS API */
gboolean make_dns_request (struct rspamd_dns_resolver *resolver,
struct rspamd_async_session *session, memory_pool_t *pool, dns_callback_type cb,
gpointer ud, enum rspamd_request_type type, ...);
-const char *dns_strerror (enum dns_rcode rcode);
-const char *dns_strtype (enum rspamd_request_type type);
+const gchar *dns_strerror (enum dns_rcode rcode);
+const gchar *dns_strtype (enum rspamd_request_type type);
#endif
* Sorted by name to use bsearch
*/
static struct _fl {
- const char *name;
+ const gchar *name;
rspamd_internal_func_t func;
void *user_data;
} rspamd_functions_list[] = {
"is_recipients_sorted", rspamd_is_recipients_sorted, NULL},};
static struct _fl *list_ptr = &rspamd_functions_list[0];
-static uint32_t functions_number = sizeof (rspamd_functions_list) / sizeof (struct _fl);
+static guint32 functions_number = sizeof (rspamd_functions_list) / sizeof (struct _fl);
static gboolean list_allocated = FALSE;
/* Bsearch routine */
-static int
+static gint
fl_cmp (const void *s1, const void *s2)
{
struct _fl *fl1 = (struct _fl *)s1;
/* Cache for regular expressions that are used in functions */
void *
-re_cache_check (const char *line, memory_pool_t *pool)
+re_cache_check (const gchar *line, memory_pool_t *pool)
{
GHashTable *re_cache;
}
void
-re_cache_add (char *line, void *pointer, memory_pool_t *pool)
+re_cache_add (gchar *line, void *pointer, memory_pool_t *pool)
{
GHashTable *re_cache;
/* Task cache functions */
void
-task_cache_add (struct worker_task *task, struct rspamd_regexp *re, int32_t result)
+task_cache_add (struct worker_task *task, struct rspamd_regexp *re, gint32 result)
{
if (result == 0) {
result = -1;
g_hash_table_insert (task->re_cache, re->regexp_text, GINT_TO_POINTER (result));
}
-int32_t
+gint32
task_cache_check (struct worker_task *task, struct rspamd_regexp *re)
{
gpointer res;
- int32_t r;
+ gint32 r;
if ((res = g_hash_table_lookup (task->re_cache, re->regexp_text)) != NULL) {
r = GPOINTER_TO_INT (res);
* Functions for parsing expressions
*/
struct expression_stack {
- char op;
+ gchar op;
struct expression_stack *next;
};
* Push operand or operator to stack
*/
static struct expression_stack *
-push_expression_stack (memory_pool_t * pool, struct expression_stack *head, char op)
+push_expression_stack (memory_pool_t * pool, struct expression_stack *head, gchar op)
{
struct expression_stack *new;
new = memory_pool_alloc (pool, sizeof (struct expression_stack));
/*
* Delete symbol from stack, return pointer to operand or operator (casted to void* )
*/
-static char
+static gchar
delete_expression_stack (struct expression_stack **head)
{
struct expression_stack *cur;
- char res;
+ gchar res;
if (*head == NULL)
return 0;
/*
* Return operation priority
*/
-static int
-logic_priority (char a)
+static gint
+logic_priority (gchar a)
{
switch (a) {
case '!':
* Return TRUE if symbol is operation symbol
*/
static gboolean
-is_operation_symbol (char a)
+is_operation_symbol (gchar a)
{
switch (a) {
case '!':
* Return TRUE if symbol can be regexp flag
*/
static gboolean
-is_regexp_flag (char a)
+is_regexp_flag (gchar a)
{
switch (a) {
case 'i':
}
static void
-insert_expression (memory_pool_t * pool, struct expression **head, int type, char op, void *operand, const char *orig)
+insert_expression (memory_pool_t * pool, struct expression **head, gint type, gchar op, void *operand, const gchar *orig)
{
struct expression *new, *cur;
}
static struct expression *
-maybe_parse_expression (memory_pool_t * pool, char *line)
+maybe_parse_expression (memory_pool_t * pool, gchar *line)
{
struct expression *expr;
- char *p = line;
+ gchar *p = line;
while (*p) {
if (is_operation_symbol (*p)) {
* Memory is allocated from given pool
*/
struct expression *
-parse_expression (memory_pool_t * pool, char *line)
+parse_expression (memory_pool_t * pool, gchar *line)
{
struct expression *expr = NULL;
struct expression_stack *stack = NULL;
struct expression_function *func = NULL, *old;
struct expression *arg;
GQueue *function_stack;
- char *p, *c, *str, op, *copy;
+ gchar *p, *c, *str, op, *copy;
gboolean in_regexp = FALSE;
- int brackets = 0;
+ gint brackets = 0;
enum {
SKIP_SPACES,
* Rspamd regexp utility functions
*/
struct rspamd_regexp *
-parse_regexp (memory_pool_t * pool, char *line, gboolean raw_mode)
+parse_regexp (memory_pool_t * pool, gchar *line, gboolean raw_mode)
{
- char *begin, *end, *p, *src, *start;
+ gchar *begin, *end, *p, *src, *start;
struct rspamd_regexp *result, *check;
- int regexp_flags = G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE;
+ gint regexp_flags = G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE;
GError *err = NULL;
src = line;
}
void
-register_expression_function (const char *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;
return FALSE;
}
- debug_task ("try to get header %s", (char *)arg->data);
- headerlist = message_get_header (task->task_pool, task->message, (char *)arg->data);
+ debug_task ("try to get header %s", (gchar *)arg->data);
+ headerlist = message_get_header (task->task_pool, task->message, (gchar *)arg->data);
if (headerlist) {
g_list_free (headerlist);
return TRUE;
gboolean
rspamd_parts_distance (struct worker_task * task, GList * args, void *unused)
{
- int threshold, diff;
+ gint threshold, diff;
struct mime_text_part *p1, *p2;
GList *cur;
struct expression_argument *arg;
else {
errno = 0;
arg = get_function_arg (args->data, task, TRUE);
- threshold = strtoul ((char *)arg->data, NULL, 10);
+ threshold = strtoul ((gchar *)arg->data, NULL, 10);
if (errno != 0) {
- msg_info ("bad numeric value for threshold \"%s\", assume it 100", (char *)args->data);
+ msg_info ("bad numeric value for threshold \"%s\", assume it 100", (gchar *)args->data);
threshold = 100;
}
}
gboolean
rspamd_content_type_compare_param (struct worker_task * task, GList * args, void *unused)
{
- char *param_name, *param_pattern;
- const char *param_data;
+ gchar *param_name, *param_pattern;
+ const gchar *param_data;
struct rspamd_regexp *re;
struct expression_argument *arg;
GMimeObject *part;
const GMimeContentType *ct;
- int r;
+ gint r;
if (args == NULL) {
msg_warn ("no parameters to function");
gboolean
rspamd_content_type_has_param (struct worker_task * task, GList * args, void *unused)
{
- char *param_name;
- const char *param_data;
+ gchar *param_name;
+ const gchar *param_data;
struct expression_argument *arg;
GMimeObject *part;
const GMimeContentType *ct;
gboolean
rspamd_content_type_is_subtype (struct worker_task *task, GList * args, void *unused)
{
- char *param_pattern;
+ gchar *param_pattern;
struct rspamd_regexp *re;
struct expression_argument *arg;
GMimeObject *part;
GMimeContentType *ct;
- int r;
+ gint r;
if (args == NULL) {
msg_warn ("no parameters to function");
gboolean
rspamd_content_type_is_type (struct worker_task * task, GList * args, void *unused)
{
- char *param_pattern;
+ gchar *param_pattern;
struct rspamd_regexp *re;
GMimeObject *part;
GMimeContentType *ct;
struct expression_argument *arg;
- int r;
+ gint r;
if (args == NULL) {
msg_warn ("no parameters to function");
}
struct addr_list {
- const char *name;
- const char *addr;
+ const gchar *name;
+ const gchar *addr;
};
#define COMPARE_RCPT_LEN 3
InternetAddress *addr;
double threshold;
struct addr_list *ar;
- char *c;
- int num, i, j, hits = 0, total = 0;
+ gchar *c;
+ gint num, i, j, hits = 0, total = 0;
if (args == NULL) {
msg_warn ("no parameters to function");
arg = get_function_arg (args->data, task, TRUE);
errno = 0;
- threshold = strtod ((char *)arg->data, NULL);
+ threshold = strtod ((gchar *)arg->data, NULL);
if (errno != 0) {
- msg_warn ("invalid numeric value '%s': %s", (char *)arg->data, strerror (errno));
+ msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
return FALSE;
}
struct addr_list current = { NULL, NULL }, previous = {
NULL, NULL};
#ifdef GMIME24
- int num, i;
+ gint num, i;
#endif
/* Do not check to short address lists */
cur = ia;
for (i = 0; i < num; i ++) {
addr = internet_address_list_get_address ((InternetAddressList *)cur, i);
- current.addr = (char *)internet_address_get_name (addr);
+ current.addr = (gchar *)internet_address_get_name (addr);
if (previous.addr != NULL) {
if (current.addr && g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
res = FALSE;
}
static inline gboolean
-compare_subtype (struct worker_task *task, GMimeContentType * ct, char *subtype)
+compare_subtype (struct worker_task *task, GMimeContentType * ct, gchar *subtype)
{
struct rspamd_regexp *re;
- int r;
+ gint r;
if (*subtype == '/') {
/* This is regexp, so compile and create g_regexp object */
}
static inline gboolean
-compare_len (struct mime_part *part, int min, int max)
+compare_len (struct mime_part *part, gint min, gint max)
{
if (min == 0 && max == 0) {
return TRUE;
}
gboolean
-common_has_content_part (struct worker_task * task, char *param_type, char *param_subtype, int min_len, int max_len)
+common_has_content_part (struct worker_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;
- int r;
+ gint r;
cur = g_list_first (task->parts);
while (cur) {
gboolean
rspamd_has_content_part (struct worker_task * task, GList * args, void *unused)
{
- char *param_type = NULL, *param_subtype = NULL;
+ gchar *param_type = NULL, *param_subtype = NULL;
struct expression_argument *arg;
if (args == NULL) {
gboolean
rspamd_has_content_part_len (struct worker_task * task, GList * args, void *unused)
{
- char *param_type = NULL, *param_subtype = NULL;
- int min = 0, max = 0;
+ gchar *param_type = NULL, *param_subtype = NULL;
+ gint min = 0, max = 0;
struct expression_argument *arg;
if (args == NULL) {
errno = 0;
min = strtoul (arg->data, NULL, 10);
if (errno != 0) {
- msg_warn ("invalid numeric value '%s': %s", (char *)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", (char *)arg->data, strerror (errno));
+ msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
return FALSE;
}
}
enc_req = g_mime_content_encoding_from_string (arg->data);
if (enc_req == GMIME_CONTENT_ENCODING_DEFAULT) {
#endif
- msg_warn ("bad encoding type: %s", (char *)arg->data);
+ msg_warn ("bad encoding type: %s", (gchar *)arg->data);
return FALSE;
}
#endif
- debug_task ("got encoding in part: %d and compare with %d", (int)part_enc, (int)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
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", (char *)arg->data);
+ msg_warn ("unknown tag type passed as argument: %s", (gchar *)arg->data);
return FALSE;
}
* Rspamd expression function
*/
struct expression_function {
- char *name; /**< name of function */
+ gchar *name; /**< name of function */
GList *args; /**< its args */
};
} type; /**< expression type */
union {
void *operand;
- char operation;
+ gchar operation;
} content; /**< union for storing operand or operation code */
const gchar *orig; /**< original line */
struct expression *next; /**< chain link */
* @param line incoming line
* @return regexp structure or NULL in case of error
*/
-struct rspamd_regexp* parse_regexp (memory_pool_t *pool, char *line, gboolean raw_mode);
+struct rspamd_regexp* parse_regexp (memory_pool_t *pool, 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 (memory_pool_t *pool, char *line);
+struct expression* parse_expression (memory_pool_t *pool, gchar *line);
/**
* Call specified fucntion and return boolean result
* @param name name of function
* @param func pointer to function
*/
-void register_expression_function (const char *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 line symbolic representation
* @param pointer regexp data
*/
-void re_cache_add (char *line, void *pointer, memory_pool_t *pool);
+void re_cache_add (gchar *line, void *pointer, memory_pool_t *pool);
/**
* Check regexp in cache
* @param line symbolic representation
* @return pointer to regexp data or NULL if regexp is not found
*/
-void * re_cache_check (const char *line, memory_pool_t *pool);
+void * re_cache_check (const gchar *line, memory_pool_t *pool);
/**
* Add regexp to regexp task cache
* @param pointer regexp data
* @param result numeric result of this regexp
*/
-void task_cache_add (struct worker_task *task, struct rspamd_regexp *re, int32_t result);
+void task_cache_add (struct worker_task *task, struct rspamd_regexp *re, gint32 result);
/**
* Check regexp in cache
* @param pointer regexp data
* @return numeric result if value exists or -1 if not
*/
-int32_t task_cache_check (struct worker_task *task, struct rspamd_regexp *re);
+gint32 task_cache_check (struct worker_task *task, struct rspamd_regexp *re);
/**
* Parse and return a single function argument for a function (may recurse)
#endif
static void
-insert_metric_result (struct worker_task *task, struct metric *metric, const char *symbol, double flag, GList * opts)
+insert_metric_result (struct worker_task *task, struct metric *metric, const gchar *symbol, double flag, GList * opts)
{
struct metric_result *metric_res;
struct symbol *s;
}
void
-insert_result (struct worker_task *task, const char *symbol, double flag, GList * opts)
+insert_result (struct worker_task *task, const gchar *symbol, double flag, GList * opts)
{
struct metric *metric;
struct cache_item *item;
* Call perl or C module function for specified part of message
*/
static void
-call_filter_by_name (struct worker_task *task, const char *name, enum filter_type filt_type)
+call_filter_by_name (struct worker_task *task, const gchar *name, enum filter_type filt_type)
{
struct module_ctx *c_module;
- int res = 0;
+ gint res = 0;
switch (filt_type) {
case C_FILTER:
break;
}
- debug_task ("filter name: %s, result: %d", name, (int)res);
+ debug_task ("filter name: %s, result: %d", name, (gint)res);
}
/* Return true if metric has score that is more than spam score for it */
return FALSE;
}
-static int
+static gint
continue_process_filters (struct worker_task *task)
{
GList *cur;
return 1;
}
-int
+gint
process_filters (struct worker_task *task)
{
GList *cur;
static gboolean
check_autolearn (struct statfile_autolearn_params *params, struct worker_task *task)
{
- char *metric_name = DEFAULT_METRIC;
+ gchar *metric_name = DEFAULT_METRIC;
struct metric_result *metric_res;
GList *cur;
if (params->metric != NULL) {
- metric_name = (char *)params->metric;
+ metric_name = (gchar *)params->metric;
}
/* First check threshold */
}
void
-process_autolearn (struct statfile *st, struct worker_task *task, GTree * tokens, struct classifier *classifier, char *filename, struct classifier_ctx *ctx)
+process_autolearn (struct statfile *st, struct worker_task *task, GTree * tokens, struct classifier *classifier, gchar *filename, struct classifier_ctx *ctx)
{
stat_file_t *statfile;
struct statfile *unused;
GTree *tokens = NULL;
GList *cur;
f_str_t c;
- char *header = NULL;
+ gchar *header = NULL;
if ((header = g_hash_table_lookup (cl->opts, "header")) != NULL) {
cur = message_get_header (task->task_pool, task->message, header);
insert_metric_header (gpointer metric_name, gpointer metric_value, gpointer data)
{
struct worker_task *task = (struct worker_task *)data;
- int r = 0;
+ gint r = 0;
/* Try to be rfc2822 compatible and avoid long headers with folding */
- char header_name[128], outbuf[1000];
+ gchar header_name[128], outbuf[1000];
GList *symbols = NULL, *cur;
struct metric_result *metric_res = (struct metric_result *)metric_value;
double ms, rs;
cur = symbols;
while (cur) {
if (g_list_next (cur) != NULL) {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s,", (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s,", (gchar *)cur->data);
}
else {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s", (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s", (gchar *)cur->data);
}
cur = g_list_next (cur);
}
struct worker_task;
-typedef double (*metric_cons_func)(struct worker_task *task, const char *metric_name, const char *func_name);
+typedef double (*metric_cons_func)(struct worker_task *task, const gchar *metric_name, const gchar *func_name);
typedef void (*filter_func)(struct worker_task *task);
enum filter_type { C_FILTER, PERL_FILTER };
* Filter structure
*/
struct filter {
- char *func_name; /**< function name */
+ gchar *func_name; /**< function name */
enum filter_type type; /**< filter type (c or perl) */
module_t *module;
};
* Common definition of metric
*/
struct metric {
- char *name; /**< name of metric */
- char *func_name; /**< name of consolidation function */
+ 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 */
double required_score; /**< required score for this metric */
* @param task worker's task that present message from user
* @return 0 - if there is non-finished tasks and 1 if processing is completed
*/
-int process_filters (struct worker_task *task);
+gint process_filters (struct worker_task *task);
/**
* Process message with statfiles
* @param flag numeric weight for symbol
* @param opts list of symbol's options
*/
-void insert_result (struct worker_task *task, const char *symbol, double flag, GList *opts);
+void insert_result (struct worker_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
* @param metric_name name of metric
* @return result metric weight
*/
-double factor_consolidation_func (struct worker_task *task, const char *metric_name, const char *unused);
+double factor_consolidation_func (struct worker_task *task, const gchar *metric_name, const gchar *unused);
#endif
* Search first occurence of character in string
*/
ssize_t
-fstrchr (f_str_t * src, char c)
+fstrchr (f_str_t * src, gchar c)
{
register ssize_t cur = 0;
* Search last occurence of character in string
*/
ssize_t
-fstrrchr (f_str_t * src, char c)
+fstrrchr (f_str_t * src, gchar c)
{
register ssize_t cur = src->len;
* 1 - word was extracted and there are more words
* 0 - last word extracted
*/
-int
-fstrtok (f_str_t * text, const char *sep, f_tok_t * state)
+gint
+fstrtok (f_str_t * text, const gchar *sep, f_tok_t * state)
{
register size_t cur;
- const char *csep = sep;
+ const gchar *csep = sep;
if (state->pos >= text->len) {
return -1;
fstrcat (f_str_t * dest, f_str_t * src)
{
register size_t cur = 0;
- char *p = dest->begin + dest->len;
+ gchar *p = dest->begin + dest->len;
if (dest->size < src->len + dest->len) {
return 0;
/*
* Make copy of string to 0-terminated string
*/
-char *
+gchar *
fstrcstr (f_str_t * str, memory_pool_t * pool)
{
- char *res;
+ gchar *res;
res = memory_pool_alloc (pool, str->len + 1);
memcpy (res, str->begin, str->len);
/*
* Push one character to fstr
*/
-int
-fstrpush (f_str_t * dest, char c)
+gint
+fstrpush (f_str_t * dest, gchar c)
{
if (dest->size < dest->len) {
/* Need to reallocate string */
/*
* Return hash value for a string
*/
-uint32_t
+guint32
fstrhash (f_str_t * str)
{
size_t i;
- uint32_t hval;
- uint32_t tmp;
- char *c = str->begin;
+ guint32 hval;
+ guint32 tmp;
+ gchar *c = str->begin;
if (str == NULL) {
return 0;
void
fstrstrip (f_str_t * str)
{
- char *p = str->begin;
- int r = 0;
+ gchar *p = str->begin;
+ gint r = 0;
while (r < str->len) {
if (g_ascii_isspace (*p)) {
#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 {
- char *begin;
+ gchar *begin;
size_t len;
size_t size;
} f_str_t;
typedef struct f_str_buf_s {
f_str_t *buf;
- char *pos;
+ gchar *pos;
size_t free;
} f_str_buf_t;
/*
* Search first occurence of character in string
*/
-ssize_t fstrchr (f_str_t *src, char c);
+ssize_t fstrchr (f_str_t *src, gchar c);
/*
* Search last occurence of character in string
*/
-ssize_t fstrrchr (f_str_t *src, char c);
+ssize_t fstrrchr (f_str_t *src, gchar c);
/*
* Search for pattern in orig
* Split string by tokens
* word contains parsed word
*/
-int fstrtok (f_str_t *text, const char *sep, f_tok_t *state);
+gint fstrtok (f_str_t *text, const gchar *sep, f_tok_t *state);
/*
* Copy one string into other
/*
* Push one character to fstr
*/
-int fstrpush (f_str_t *dest, char c);
+gint fstrpush (f_str_t *dest, gchar c);
/*
* Allocate memory for f_str_t
/*
* Return fast hash value for fixed string
*/
-uint32_t fstrhash (f_str_t *str);
+guint32 fstrhash (f_str_t *str);
/*
* Make copy of string to 0-terminated string
*/
-char* fstrcstr (f_str_t *str, memory_pool_t *pool);
+gchar* fstrcstr (f_str_t *str, memory_pool_t *pool);
/*
* Strip fstr string from space symbols
#define HASH_INIT 0x28021967
struct roll_state {
- uint32_t h[3];
- char window[ROLL_WINDOW_SIZE];
- int n;
+ guint32 h[3];
+ gchar window[ROLL_WINDOW_SIZE];
+ gint n;
};
static struct roll_state rs;
/* Rolling hash function based on Adler-32 checksum */
-static uint32_t
-fuzzy_roll_hash (char c)
+static guint32
+fuzzy_roll_hash (gchar c)
{
/* Check window position */
if (rs.n == ROLL_WINDOW_SIZE) {
}
/* A simple non-rolling hash, based on the FNV hash */
-static uint32_t
-fuzzy_fnv_hash (char c, uint32_t hval)
+static guint32
+fuzzy_fnv_hash (gchar c, guint32 hval)
{
hval ^= c;
hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
}
/* Calculate blocksize depending on length of input */
-static uint32_t
-fuzzy_blocksize (uint32_t len)
+static guint32
+fuzzy_blocksize (guint32 len)
{
if (len < MIN_FUZZY_BLOCK_SIZE) {
/* Update hash with new symbol */
void
-fuzzy_update (fuzzy_hash_t * h, char c)
+fuzzy_update (fuzzy_hash_t * h, gchar c)
{
h->rh = fuzzy_roll_hash (c);
h->h = fuzzy_fnv_hash (c, h->h);
*
* Replace cost is normally 1, and 2 with nonzero xcost.
*/
-uint32_t
-lev_distance (char *s1, int len1, char *s2, int len2)
+guint32
+lev_distance (gchar *s1, gint len1, gchar *s2, gint len2)
{
- int i;
- int *row; /* we only need to keep one row of costs */
- int *end;
- int half, nx;
- char *sx, *char2p, char1;
- int *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) {
half = len1 >> 1;
/* initalize first row */
- row = g_malloc (len2 * sizeof (int));
+ row = g_malloc (len2 * sizeof (gint));
end = row + len2 - 1;
for (i = 0; i < len2; i++) {
row[i] = i;
fuzzy_init (f_str_t * in, memory_pool_t * pool)
{
fuzzy_hash_t *new;
- int i, repeats = 0;
- char *c = in->begin, last = '\0';
+ gint i, repeats = 0;
+ gchar *c = in->begin, last = '\0';
new = memory_pool_alloc0 (pool, sizeof (fuzzy_hash_t));
bzero (&rs, sizeof (rs));
}
/* Compare score of difference between two hashes 0 - different hashes, 100 - identical hashes */
-int
+gint
fuzzy_compare_hashes (fuzzy_hash_t * h1, fuzzy_hash_t * h2)
{
- int 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) {
#define FUZZY_HASHLEN 64
typedef struct fuzzy_hash_s {
- char hash_pipe[FUZZY_HASHLEN]; /**< result hash */
- uint32_t block_size; /**< current blocksize */
- uint32_t rh; /**< roll hash value */
- uint32_t h; /**< hash of block */
- uint32_t 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;
/**
* @param h2 second hash
* @return result in percents 0 - different hashes, 100 - identical hashes
*/
-int fuzzy_compare_hashes (fuzzy_hash_t *h1, fuzzy_hash_t *h2);
+gint fuzzy_compare_hashes (fuzzy_hash_t *h1, fuzzy_hash_t *h2);
-uint32_t lev_distance (char *s1, int len1, char *s2, int len2);
+guint32 lev_distance (gchar *s1, gint len1, gchar *s2, gint len2);
#endif
static bloom_filter_t *bf;
/* Number of cache modifications */
-static uint32_t mods = 0;
-static uint32_t max_mods = DEFAULT_MOD_LIMIT;
+static guint32 mods = 0;
+static guint32 max_mods = DEFAULT_MOD_LIMIT;
/* Frequent score number */
-static uint32_t frequent_score = DEFAULT_FREQUENT_SCORE;
+static guint32 frequent_score = DEFAULT_FREQUENT_SCORE;
/* For evtimer */
static struct timeval tmv;
static struct event tev;
static struct rspamd_stat *server_stat;
struct rspamd_fuzzy_node {
- int32_t value;
- int32_t flag;
- uint64_t time;
+ gint32 value;
+ gint32 flag;
+ guint64 time;
fuzzy_hash_t h;
};
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t *info, void *unused)
#endif
{
switch (signo) {
static void
sync_cache (struct rspamd_worker *wrk)
{
- int fd, i;
- char *filename, *exp_str, header[4];
+ gint fd, i;
+ gchar *filename, *exp_str, header[4];
GList *cur, *tmp;
struct rspamd_fuzzy_node *node;
- uint64_t expire, now;
+ guint64 expire, now;
#ifdef WITH_JUDY
PPvoid_t pvalue;
- char indexbuf[1024], tmpindex[1024];
+ gchar indexbuf[1024], tmpindex[1024];
#endif
/* Check for modifications */
(void)lock_file (fd, FALSE);
- now = (uint64_t) time (NULL);
+ now = (guint64) time (NULL);
/* Fill header */
memcpy (header, FUZZY_FILE_MAGIC, 3);
- header[3] = (char)CURRENT_FUZZY_VERSION;
+ 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));
goto end;
}
static void
-sigterm_handler (int fd, short what, void *arg)
+sigterm_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
static struct timeval tv = {
* Config reload is designed by sending sigusr to active workers and pending shutdown of them
*/
static void
-sigusr_handler (int fd, short what, void *arg)
+sigusr_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
static gboolean
read_hashes_file (struct rspamd_worker *wrk)
{
- int r, fd, i, version = 0;
+ gint r, fd, i, version = 0;
struct stat st;
- char *filename, header[4];
+ gchar *filename, header[4];
gboolean touch_stat = TRUE;
struct rspamd_fuzzy_node *node;
struct {
- int32_t value;
- uint64_t time;
+ gint32 value;
+ guint64 time;
fuzzy_hash_t h;
} legacy_node;
#ifdef WITH_JUDY
if ((r = read (fd, header, sizeof (header))) == sizeof (header)) {
if (memcmp (header, FUZZY_FILE_MAGIC, sizeof (header) - 1) == 0) {
/* We have version in last byte of header */
- version = (int)header[3];
+ version = (gint)header[3];
if (version > CURRENT_FUZZY_VERSION) {
msg_err ("unsupported version of fuzzy hash file: %d", version);
return FALSE;
}
- msg_info ("reading fuzzy hashes storage file of version %d of size %d", version, (int)(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 */
}
static inline struct rspamd_fuzzy_node *
-check_hash_node (GQueue *hash, fuzzy_hash_t *s, int update_value)
+check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value)
{
GList *cur;
struct rspamd_fuzzy_node *h;
- int prob = 0;
+ gint prob = 0;
#ifdef WITH_JUDY
PPvoid_t pvalue;
return NULL;
}
-static int
-process_check_command (struct fuzzy_cmd *cmd, int *flag)
+static gint
+process_check_command (struct fuzzy_cmd *cmd, gint *flag)
{
fuzzy_hash_t s;
struct rspamd_fuzzy_node *h;
h = g_malloc (sizeof (struct rspamd_fuzzy_node));
memcpy (&h->h.hash_pipe, &cmd->hash, sizeof (cmd->hash));
h->h.block_size = cmd->blocksize;
- h->time = (uint64_t) time (NULL);
+ h->time = (guint64) time (NULL);
h->value = cmd->value;
h->flag = cmd->flag;
#ifdef WITH_JUDY
static void
process_fuzzy_command (struct fuzzy_session *session)
{
- int r, flag = 0;
- char buf[64];
+ gint r, flag = 0;
+ gchar buf[64];
switch (session->cmd.cmd) {
case FUZZY_CHECK:
* Accept new connection and construct task
*/
static void
-accept_fuzzy_socket (int fd, short what, void *arg)
+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 {
u_char cmd;
- uint32_t blocksize;
- int32_t value;
+ guint32 blocksize;
+ gint32 value;
u_char hash[FUZZY_HASHLEN];
} legacy_cmd;
}
static void
-sync_callback (int fd, short what, void *arg)
+sync_callback (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Timer event */
{
struct sigaction signals;
struct event sev;
- int retries = 0;
- char *value;
+ gint retries = 0;
+ gchar *value;
worker->srv->pid = getpid ();
worker->srv->type = TYPE_FUZZY;
struct fuzzy_cmd {
u_char cmd;
- uint32_t blocksize;
- int32_t value;
- int32_t flag;
+ guint32 blocksize;
+ gint32 value;
+ gint32 flag;
u_char hash[FUZZY_HASHLEN];
};
struct fuzzy_session {
struct rspamd_worker *worker;
struct fuzzy_cmd cmd;
- int fd;
+ gint fd;
u_char *pos;
socklen_t salen;
struct sockaddr_storage sa;
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t *info, void *unused)
#endif
{
switch (signo) {
}
static void
-sigterm_handler (int fd, short what, void *arg)
+sigterm_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
static struct timeval tv = {
* Config reload is designed by sending sigusr to active workers and pending shutdown of them
*/
static void
-sigusr_handler (int fd, short what, void *arg)
+sigusr_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
struct greylist_session {
struct rspamd_worker *worker;
- int fd;
+ gint fd;
socklen_t salen;
struct sockaddr_storage sa;
guint8 *pos;
{
struct rspamd_grey_reply reply;
#ifdef WITH_JUDY
- int rc;
+ gint rc;
struct rspamd_grey_item **pitem = NULL;
JHSG (pitem, ctx->jtree, cmd->data, CHECKSUM_SIZE);
* Accept new connection and construct task
*/
static void
-accept_greylist_socket (int fd, short what, void *arg)
+accept_greylist_socket (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
struct greylist_session session;
config_greylist_worker (struct rspamd_worker *worker)
{
struct greylist_ctx *ctx;
- char *value;
+ gchar *value;
ctx = g_malloc0 (sizeof (struct greylist_ctx));
#ifdef WITH_JUDY
{
struct sigaction signals;
struct event sev;
- int retries = 0;
+ gint retries = 0;
worker->srv->pid = getpid ();
worker->srv->type = TYPE_GREYLIST;
typedef struct _entity entity;
struct _entity {
- char *name;
+ gchar *name;
uint code;
- char *replacement;
+ gchar *replacement;
};
{"or", 8744, "|"},
{"cap", 8745, NULL},
{"cup", 8746, NULL},
- {"int", 8747, NULL},
+ {"gint", 8747, NULL},
{"there4", 8756, NULL},
{"sim", 8764, NULL},
{"cong", 8773, NULL},
static entity *entities_defs_num = NULL;
-static int
+static gint
tag_cmp (const void *m1, const void *m2)
{
const struct html_tag *p1 = m1;
return g_ascii_strcasecmp (p1->name, p2->name);
}
-static int
+static gint
entity_cmp (const void *m1, const void *m2)
{
const entity *p1 = m1;
return g_ascii_strcasecmp (p1->name, p2->name);
}
-static int
+static gint
entity_cmp_num (const void *m1, const void *m2)
{
const entity *p1 = m1;
}
static GNode *
-construct_html_node (memory_pool_t * pool, char *text)
+construct_html_node (memory_pool_t * pool, gchar *text)
{
struct html_node *html;
GNode *n = NULL;
struct html_tag key, *found;
- char t;
- int taglen = strlen (text);
+ gchar t;
+ gint taglen = strlen (text);
if (text == NULL || *text == '\0') {
return NULL;
}
struct html_tag *
-get_tag_by_name (const char *name)
+get_tag_by_name (const gchar *name)
{
struct html_tag key;
/* Decode HTML entitles in text */
void
-decode_entitles (char *s, guint * len)
+decode_entitles (gchar *s, guint * len)
{
guint l, rep_len;
- char *t = s; /* t - tortoise */
- char *h = s; /* h - hare */
- char *e = s;
- char *end_ptr;
- int state = 0, val, base;
+ 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) {
static gchar *
html_strcasestr (const gchar *s, const gchar *find)
{
- char c, sc;
+ gchar c, sc;
size_t len;
if ((c = *find++) != 0) {
}
static void
-parse_tag_url (struct worker_task *task, struct mime_text_part *part, tag_id_t id, char *tag_text)
+parse_tag_url (struct worker_task *task, struct mime_text_part *part, tag_id_t id, gchar *tag_text)
{
- char *c = NULL, *p;
- int len, rc;
- char *url_text;
+ gchar *c = NULL, *p;
+ gint len, rc;
+ gchar *url_text;
struct uri *url;
gboolean got_single_quote = FALSE, got_double_quote = FALSE;
}
gboolean
-add_html_node (struct worker_task *task, memory_pool_t * pool, struct mime_text_part *part, char *tag_text, GNode ** cur_level)
+add_html_node (struct worker_task *task, memory_pool_t * pool, struct mime_text_part *part, gchar *tag_text, GNode ** cur_level)
{
GNode *new;
struct html_node *data;
struct html_tag {
tag_id_t id;
- const char *name;
- int flags;
+ const gchar *name;
+ gint flags;
};
struct html_node {
struct html_tag *tag;
- int flags;
+ gint flags;
};
/* Forwarded declaration */
struct worker_task;
-gboolean add_html_node (struct worker_task *task, memory_pool_t *pool, struct mime_text_part *part, char *tag_text, GNode **cur_level);
-struct html_tag * get_tag_by_name (const char *name);
-void decode_entitles (char *s, guint *len);
+gboolean add_html_node (struct worker_task *task, memory_pool_t *pool, struct mime_text_part *part, gchar *tag_text, GNode **cur_level);
+struct html_tag * get_tag_by_name (const gchar *name);
+void decode_entitles (gchar *s, guint *len);
#endif
}
}
-const char *
+const gchar *
image_type_str (enum known_image_types type)
{
switch (type) {
GByteArray *data;
guint32 width;
guint32 height;
- const char *filename;
+ const gchar *filename;
};
void process_images (struct worker_task *task);
-const char *image_type_str (enum known_image_types type);
+const gchar *image_type_str (enum known_image_types type);
#endif /* IMAGES_H_ */
#include "modules.h"
#include "message.h"
-static char greetingbuf[1024];
+static gchar greetingbuf[1024];
static struct timeval io_tv;
static gboolean lmtp_write_socket (void *arg);
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t *info, void *unused)
#endif
{
switch (signo) {
* Config reload is designed by sending sigusr to active workers and pending shutdown of them
*/
static void
-sigusr_handler (int fd, short what, void *arg)
+sigusr_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
* Accept new connection and construct task
*/
static void
-accept_socket (int fd, short what, void *arg)
+accept_socket (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
union sa_union su;
struct worker_task *new_task;
struct rspamd_lmtp_proto *lmtp;
socklen_t addrlen = sizeof (su.ss);
- int nfd;
+ gint nfd;
if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
start_lmtp_worker (struct rspamd_worker *worker)
{
struct sigaction signals;
- int i;
- char *hostbuf;
- long int hostmax;
+ gint i;
+ gchar *hostbuf;
+ gsize hostmax;
worker->srv->pid = getpid ();
worker->srv->type = TYPE_LMTP;
.len = sizeof (".\r\n") - 1
};
-static const char *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 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
* return <> if no valid address detected
*/
-static char *
+static gchar *
extract_mail (memory_pool_t * pool, f_str_t * line)
{
GError *err = NULL;
- char *match;
+ gchar *match;
GMatchInfo *info;
if (mail_re == NULL) {
}
static gboolean
-out_lmtp_reply (struct worker_task *task, int code, char *rcode, char *msg)
+out_lmtp_reply (struct worker_task *task, gint code, gchar *rcode, gchar *msg)
{
- char outbuf[OUTBUFSIZ];
- int r;
+ gchar outbuf[OUTBUFSIZ];
+ gint r;
if (*rcode == '\0') {
r = rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s\r\n", code, msg);
return TRUE;
}
-int
+gint
read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
{
- char *c, *rcpt;
+ gchar *c, *rcpt;
f_str_t fstr;
- unsigned int i = 0, l = 0, size;
+ guint i = 0, l = 0, size;
switch (lmtp->state) {
case LMTP_READ_LHLO:
static gboolean
parse_mta_str (f_str_t * in, struct mta_callback_data *cd)
{
- int r;
+ gint r;
static f_str_t okres1 = {
.begin = "250 ",
.len = sizeof ("250 ") - 1,
mta_read_socket (f_str_t * in, void *arg)
{
struct mta_callback_data *cd = (struct mta_callback_data *)arg;
- char outbuf[1024], *hostbuf, *c;
- int hostmax, r;
+ gchar outbuf[1024], *hostbuf, *c;
+ gint hostmax, r;
GList *cur;
static f_str_t contres1 = {
.begin = "250-",
cur = g_list_first (cd->task->rcpt);
r = 0;
while (cur) {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "RCPT TO: <%s>" CRLF, (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "RCPT TO: <%s>" CRLF, (gchar *)cur->data);
cur = g_list_next (cur);
}
/*
* Deliver mail via smtp or lmtp
*/
-static int
+static gint
lmtp_deliver_mta (struct worker_task *task)
{
- int sock;
+ gint sock;
struct sockaddr_un *un;
struct mta_callback_data *cd;
return 0;
}
-static char *
+static gchar *
format_lda_args (struct worker_task *task)
{
- char *res, *c, *r;
+ gchar *res, *c, *r;
size_t len;
GList *rcpt;
gboolean got_args = FALSE;
rcpt = g_list_first (task->rcpt);
len -= 2;
while (rcpt) {
- len += strlen ((char *)rcpt->data) + 1;
+ len += strlen ((gchar *)rcpt->data) + 1;
rcpt = g_list_next (rcpt);
}
break;
c += 2;
rcpt = g_list_first (task->rcpt);
while (rcpt) {
- len = strlen ((char *)rcpt->data) + 1;
+ len = strlen ((gchar *)rcpt->data) + 1;
memcpy (r, rcpt->data, len);
r += len;
*r++ = ' ';
return res;
}
-static int
+static gint
lmtp_deliver_lda (struct worker_task *task)
{
- char *args, **argv;
+ gchar *args, **argv;
GMimeStream *stream;
- int rc, ecode, p[2], argc;
+ gint rc, ecode, p[2], argc;
pid_t cpid, pid;
if ((args = format_lda_args (task)) == NULL) {
return -1;
}
-int
+gint
lmtp_deliver_message (struct worker_task *task)
{
if (task->cfg->deliver_agent_path != NULL) {
}
}
-int
+gint
write_lmtp_reply (struct rspamd_lmtp_proto *lmtp)
{
- int r;
+ gint r;
struct worker_task *task = lmtp->task;
debug_task ("writing reply to client");
* @param line line of user's input
* @return 0 if line was successfully parsed and -1 if we have protocol error
*/
-int read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t *line);
+gint read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t *line);
/**
* Deliver message via lmtp/smtp or pipe to LDA
* @param task task object
* @return 0 if we wrote message and -1 if there was some error
*/
-int lmtp_deliver_message (struct worker_task *task);
+gint lmtp_deliver_message (struct worker_task *task);
/**
* Write reply for specified lmtp object
* @param lmtp lmtp object
* @return 0 if we wrote reply and -1 if there was some error
*/
-int write_lmtp_reply (struct rspamd_lmtp_proto *lmtp);
+gint write_lmtp_reply (struct rspamd_lmtp_proto *lmtp);
#endif
rspamd_log_func_t log_func;
struct config_file *cfg;
struct {
- uint32_t size;
- uint32_t used;
+ guint32 size;
+ guint32 used;
u_char *buf;
} io_buf;
- int fd;
+ gint fd;
gboolean is_buffered;
gboolean enabled;
gboolean is_debug;
pid_t pid;
enum process_type process_type;
radix_tree_t *debug_ip;
- uint32_t last_line_cksum;
- uint32_t repeats;
+ guint32 last_line_cksum;
+ guint32 repeats;
gchar *saved_message;
gchar *saved_function;
} rspamd_logger_t;
rspamd_logger_t *rspamd_log = NULL;
-static const char lf_chr = '\n';
+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);
-static inline uint32_t
+static inline guint32
rspamd_log_calculate_cksum (const gchar *message, size_t mlen)
{
const gchar *bp = message;
const gchar *be = bp + mlen;
- uint32_t hval = 0;
+ guint32 hval = 0;
while (bp < be) {
hval += (hval<<1) + (hval<<4) + (hval<<7) + (hval<<8) + (hval<<24);
- hval ^= (uint32_t)*bp++;
+ hval ^= (guint32)*bp++;
}
/* return our new hash value */
}
static void
-direct_write_log_line (void *data, int count, gboolean is_iov)
+direct_write_log_line (void *data, gint count, gboolean is_iov)
{
- char errmsg[128];
+ gchar errmsg[128];
struct iovec *iov;
- const char *line;
- int r;
+ const gchar *line;
+ gint r;
if (rspamd_log->enabled) {
if (is_iov) {
r = writev (rspamd_log->fd, iov, count);
}
else {
- line = (const char *)data;
+ line = (const gchar *)data;
r = write (rspamd_log->fd, line, count);
}
if (r == -1) {
}
/* Logging utility functions */
-int
+gint
open_log (void)
{
void
close_log (void)
{
- char tmpbuf[256];
+ gchar tmpbuf[256];
flush_log_buf ();
switch (rspamd_log->type) {
void
rspamd_set_logger (enum rspamd_log_type type, enum process_type ptype, struct config_file *cfg)
{
- char **strvec, *p, *err;
- int num, i, k;
+ gchar **strvec, *p, *err;
+ gint num, i, k;
struct in_addr addr;
- uint32_t mask = 0xFFFFFFFF;
+ guint32 mask = 0xFFFFFFFF;
if (rspamd_log == NULL) {
rspamd_log = g_malloc (sizeof (rspamd_logger_t));
}
}
-int
+gint
reopen_log (void)
{
close_log ();
void
-rspamd_common_log_function (GLogLevelFlags log_level, const char *function, const char *fmt, ...)
+rspamd_common_log_function (GLogLevelFlags log_level, const gchar *function, const gchar *fmt, ...)
{
- static char logbuf[BUFSIZ];
+ static gchar logbuf[BUFSIZ];
va_list vp;
u_char *end;
/* Fill buffer with message (limits must be checked BEFORE this call) */
static void
-fill_buffer (const struct iovec *iov, int iovcnt)
+fill_buffer (const struct iovec *iov, gint iovcnt)
{
- int 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);
/* Write message to buffer or to file */
static void
-file_log_helper (const struct iovec *iov, int iovcnt)
+file_log_helper (const struct iovec *iov, gint iovcnt)
{
size_t len = 0;
- int i;
+ gint i;
if (! rspamd_log->is_buffered) {
/* Write string directly */
static void
file_log_function (const gchar * log_domain, const gchar *function, GLogLevelFlags log_level, const gchar * message, gboolean forced, gpointer arg)
{
- char tmpbuf[256], timebuf[32];
+ gchar tmpbuf[256], timebuf[32];
time_t now;
struct tm *tms;
struct iovec iov[3];
- int r;
- uint32_t cksum;
+ gint r;
+ guint32 cksum;
size_t mlen;
- const char *cptype = NULL;
+ const gchar *cptype = NULL;
gboolean got_time = FALSE;
if (! rspamd_log->enabled) {
}
void
-rspamd_conditional_debug (uint32_t addr, const char *function, const char *fmt, ...)
+rspamd_conditional_debug (guint32 addr, const gchar *function, const gchar *fmt, ...)
{
- static char logbuf[BUFSIZ];
+ static gchar logbuf[BUFSIZ];
va_list vp;
u_char *end;
/**
* Open log file or initialize other structures
*/
-int open_log (void);
+gint open_log (void);
/**
* Close log file or destroy other structures
*/
/**
* Close and open log again
*/
-int reopen_log (void);
+gint reopen_log (void);
/**
* Set log pid
*/
/**
* Function with variable number of arguments support
*/
-void rspamd_common_log_function (GLogLevelFlags log_level, const char *function, const char *fmt, ...);
+void rspamd_common_log_function (GLogLevelFlags log_level, const gchar *function, const gchar *fmt, ...);
/**
* Conditional debug function
*/
-void rspamd_conditional_debug (uint32_t addr, const char *function, const char *fmt, ...) ;
+void rspamd_conditional_debug (guint32 addr, const gchar *function, const gchar *fmt, ...) ;
/**
* Temporary turn on debug
{
GList *cur_opt;
struct module_opt *cur;
- const char *name;
+ const gchar *name;
gboolean new_module = FALSE;
/* Get module opt structure */
/* Process single element */
void
-lua_process_element (struct config_file *cfg, const char *name, struct module_opt *opt, int idx)
+lua_process_element (struct config_file *cfg, const gchar *name, struct module_opt *opt, gint idx)
{
lua_State *L = cfg->lua_state;
- int t;
+ gint t;
double *num;
gboolean *flag;
struct classifier_callback_data {
lua_State *L;
- const char *name;
+ const gchar *name;
};
static struct statfile* lua_check_statfile (lua_State * L);
struct classifier_config **pccf;
struct worker_task **ptask;
struct statfile *st;
- int i, len;
+ gint i, len;
/* Go throught all callbacks and call them, appending results to list */
cur = g_list_first (ccf->pre_callbacks);
}
-static int
+static gint
lua_classifier_register_pre_callback (lua_State *L)
{
struct classifier_config *ccf = lua_check_classifier (L);
struct classifier_callback_data *cd;
- const char *name;
+ const gchar *name;
if (ccf) {
name = luaL_checkstring (L, 2);
}
-static int
+static gint
lua_classifier_register_post_callback (lua_State *L)
{
struct classifier_config *ccf = lua_check_classifier (L);
struct classifier_callback_data *cd;
- const char *name;
+ const gchar *name;
if (ccf) {
name = luaL_checkstring (L, 2);
}
/* Return table of statfiles indexed by theirs name */
-static int
+static gint
lua_classifier_get_statfiles (lua_State *L)
{
struct classifier_config *ccf = lua_check_classifier (L);
/* Open functions */
-int
+gint
luaopen_classifier (lua_State * L)
{
lua_newclass (L, "rspamd{classifier}", classifierlib_m);
return 1;
}
-int
+gint
luaopen_statfile (lua_State * L)
{
lua_newclass (L, "rspamd{statfile}", statfilelib_m);
/* Util functions */
void
-lua_newclass (lua_State * L, const char *classname, const struct luaL_reg *func)
+lua_newclass (lua_State * L, const gchar *classname, const struct luaL_reg *func)
{
luaL_newmetatable (L, classname); /* mt */
lua_pushstring (L, "__index");
luaL_openlib (L, NULL, func, 0);
}
-int
+gint
lua_class_tostring (lua_State * L)
{
- char buf[32];
+ gchar buf[32];
if (!lua_getmetatable (L, 1)) {
goto error;
void
-lua_setclass (lua_State * L, const char *classname, int objidx)
+lua_setclass (lua_State * L, const gchar *classname, gint objidx)
{
luaL_getmetatable (L, classname);
if (objidx < 0) {
/* assume that table is at the top */
void
-lua_set_table_index (lua_State * L, const char *index, const char *value)
+lua_set_table_index (lua_State * L, const gchar *index, const gchar *value)
{
lua_pushstring (L, index);
}
static void
-lua_common_log (GLogLevelFlags level, lua_State *L, const char *msg)
+lua_common_log (GLogLevelFlags level, lua_State *L, const gchar *msg)
{
lua_Debug d;
- char func_buf[128], *p;
+ gchar func_buf[128], *p;
if (lua_getstack (L, 1, &d) == 1) {
(void)lua_getinfo(L, "Sl", &d);
}
/*** Logger interface ***/
-static int
+static gint
lua_logger_err (lua_State * L)
{
- const char *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 2);
lua_common_log (G_LOG_LEVEL_CRITICAL, L, msg);
return 1;
}
-static int
+static gint
lua_logger_warn (lua_State * L)
{
- const char *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 2);
lua_common_log (G_LOG_LEVEL_WARNING, L, msg);
return 1;
}
-static int
+static gint
lua_logger_info (lua_State * L)
{
- const char *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 2);
lua_common_log (G_LOG_LEVEL_INFO, L, msg);
return 1;
}
-static int
+static gint
lua_logger_debug (lua_State * L)
{
- const char *msg;
+ const gchar *msg;
msg = luaL_checkstring (L, 2);
lua_common_log (G_LOG_LEVEL_DEBUG, L, msg);
return 1;
/*** Init functions ***/
-int
+gint
luaopen_rspamd (lua_State * L)
{
luaL_openlib (L, "rspamd", null_reg, 0);
return 1;
}
-int
+gint
luaopen_logger (lua_State * L)
{
/* Callback functions */
-int
-lua_call_filter (const char *function, struct worker_task *task)
+gint
+lua_call_filter (const gchar *function, struct worker_task *task)
{
- int result;
+ gint result;
struct worker_task **ptask;
lua_State *L = task->cfg->lua_state;
return result;
}
-int
-lua_call_chain_filter (const char *function, struct worker_task *task, int *marks, unsigned int number)
+gint
+lua_call_chain_filter (const gchar *function, struct worker_task *task, gint *marks, guint number)
{
- int result, i;
+ gint result, i;
lua_State *L = task->cfg->lua_state;
lua_getglobal (L, function);
/* Call custom lua function in rspamd expression */
gboolean
-lua_call_expression_func (const char *function, struct worker_task *task, GList *args, gboolean *res)
+lua_call_expression_func (const gchar *function, struct worker_task *task, GList *args, gboolean *res)
{
lua_State *L = task->cfg->lua_state;
struct worker_task **ptask;
GList *cur;
struct expression_argument *arg;
- int nargs = 0;
+ gint nargs = 0;
lua_getglobal (L, function);
ptask = lua_newuserdata (L, sizeof (struct worker_task *));
struct consolidation_callback_data {
struct worker_task *task;
double score;
- const char *func;
+ const gchar *func;
};
static void
lua_getglobal (L, data->func);
- lua_pushstring (L, (const char *)key);
+ lua_pushstring (L, (const gchar *)key);
lua_pushnumber (L, s->score);
if (lua_pcall (L, 2, 1, 0) != 0) {
msg_info ("call to %s failed", data->func);
}
double
-lua_consolidation_func (struct worker_task *task, const char *metric_name, const char *function_name)
+lua_consolidation_func (struct worker_task *task, const gchar *metric_name, const gchar *function_name)
{
struct metric_result *metric_res;
double res = 0.;
#include <lualib.h>
/* Interface definitions */
-#define LUA_FUNCTION_DEF(class, name) static int lua_##class##_##name(lua_State *L)
+#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[];
/* Common utility functions */
-void lua_newclass (lua_State *L, const char *classname, const struct luaL_reg *func);
-void lua_setclass (lua_State *L, const char *classname, int objidx);
-void lua_set_table_index (lua_State *L, const char *index, const char *value);
-int lua_class_tostring (lua_State *L);
-int luaopen_message (lua_State *L);
-int luaopen_task (lua_State *L);
-int luaopen_config (lua_State *L);
-int luaopen_metric (lua_State *L);
-int luaopen_radix (lua_State *L);
-int luaopen_hash_table (lua_State *L);
-int luaopen_trie (lua_State * L);
-int luaopen_textpart (lua_State *L);
-int luaopen_image (lua_State *L);
-int luaopen_classifier (lua_State *L);
-int luaopen_statfile (lua_State * L);
+void lua_newclass (lua_State *L, const gchar *classname, const struct luaL_reg *func);
+void lua_setclass (lua_State *L, const gchar *classname, gint objidx);
+void lua_set_table_index (lua_State *L, const gchar *index, const gchar *value);
+gint lua_class_tostring (lua_State *L);
+gint luaopen_message (lua_State *L);
+gint luaopen_task (lua_State *L);
+gint luaopen_config (lua_State *L);
+gint luaopen_metric (lua_State *L);
+gint luaopen_radix (lua_State *L);
+gint luaopen_hash_table (lua_State *L);
+gint luaopen_trie (lua_State * L);
+gint luaopen_textpart (lua_State *L);
+gint luaopen_image (lua_State *L);
+gint luaopen_classifier (lua_State *L);
+gint luaopen_statfile (lua_State * L);
void init_lua (struct config_file *cfg);
gboolean init_lua_filters (struct config_file *cfg);
/* Filters functions */
-int lua_call_filter (const char *function, struct worker_task *task);
-int lua_call_chain_filter (const char *function, struct worker_task *task, int *marks, unsigned int number);
-double lua_consolidation_func (struct worker_task *task, const char *metric_name, const char *function_name);
-gboolean lua_call_expression_func (const char *function, struct worker_task *task, GList *args, gboolean *res);
+gint lua_call_filter (const gchar *function, struct worker_task *task);
+gint lua_call_chain_filter (const gchar *function, struct worker_task *task, gint *marks, guint number);
+double lua_consolidation_func (struct worker_task *task, const gchar *metric_name, const gchar *function_name);
+gboolean lua_call_expression_func (const gchar *function, struct worker_task *task, GList *args, gboolean *res);
void lua_call_post_filters (struct worker_task *task);
-void add_luabuf (const char *line);
+void add_luabuf (const gchar *line);
/* Classify functions */
GList *call_classifier_pre_callbacks (struct classifier_config *ccf, struct worker_task *task);
/* Config file functions */
void lua_post_load_config (struct config_file *cfg);
-void lua_process_element (struct config_file *cfg, const char *name, struct module_opt *opt, int idx);
+void lua_process_element (struct config_file *cfg, const gchar *name, struct module_opt *opt, gint idx);
gboolean lua_handle_param (struct worker_task *task, gchar *mname, gchar *optname,
enum lua_var_type expected_type, gpointer *res);
}
/*** Config functions ***/
-static int
+static gint
lua_config_get_module_opt (lua_State * L)
{
struct config_file *cfg = lua_check_config (L);
- const char *mname, *optname, *val;
+ const gchar *mname, *optname, *val;
if (cfg) {
mname = luaL_checkstring (L, 2);
optname = luaL_checkstring (L, 3);
if (mname && optname) {
- val = get_module_opt (cfg, (char *)mname, (char *)optname);
+ val = get_module_opt (cfg, (gchar *)mname, (gchar *)optname);
if (val) {
lua_pushstring (L, val);
return 1;
return 1;
}
-static int
+static gint
opt_compare (gconstpointer a, gconstpointer b)
{
const struct module_opt *o1 = a,
return g_ascii_strcasecmp (o1->param, o2->param);
}
-static int
+static gint
lua_config_get_all_opt (lua_State * L)
{
struct config_file *cfg = lua_check_config (L);
- const char *mname;
+ const gchar *mname;
GList *cur_opt, *next_opt;
struct module_opt *opt, *tmp;
- int i;
+ gint i;
if (cfg) {
mname = luaL_checkstring (L, 2);
}
-static int
+static gint
lua_config_get_classifier (lua_State * L)
{
struct config_file *cfg = lua_check_config (L);
struct classifier_config *clc = NULL, **pclc = NULL;
- const char *name;
+ const gchar *name;
GList *cur;
if (cfg) {
}
struct lua_callback_data {
- const char *name;
+ const gchar *name;
lua_State *L;
};
{
struct lua_callback_data *cd = user_data;
struct worker_task **ptask;
- int i = 1;
+ gint i = 1;
struct expression_argument *arg;
GList *cur;
gboolean res = FALSE;
cur = args;
while (cur) {
arg = get_function_arg (cur->data, task, TRUE);
- lua_pushstring (cd->L, (const char *)arg->data);
+ lua_pushstring (cd->L, (const gchar *)arg->data);
cur = g_list_next (cur);
i ++;
}
return res;
}
-static int
+static gint
lua_config_register_function (lua_State *L)
{
struct config_file *cfg = lua_check_config (L);
- const char *name, *callback;
+ const gchar *name, *callback;
struct lua_callback_data *cd;
if (cfg) {
}
}
-static int
+static gint
lua_config_register_post_filter (lua_State *L)
{
struct config_file *cfg = lua_check_config (L);
- const char *callback;
+ const gchar *callback;
struct lua_callback_data *cd;
if (cfg) {
return 1;
}
-static int
+static gint
lua_config_add_radix_map (lua_State *L)
{
struct config_file *cfg = lua_check_config (L);
- const char *map_line;
+ const gchar *map_line;
radix_tree_t **r, ***ud;
if (cfg) {
}
-static int
+static gint
lua_config_add_hash_map (lua_State *L)
{
struct config_file *cfg = lua_check_config (L);
- const char *map_line;
+ const gchar *map_line;
GHashTable **r, ***ud;
if (cfg) {
}
}
-static int
+static gint
lua_config_register_symbol (lua_State * L)
{
struct config_file *cfg = lua_check_config (L);
- const char *name, *callback;
+ const gchar *name, *callback;
double weight;
struct lua_callback_data *cd;
}
/* Radix and hash table functions */
-static int
+static gint
lua_radix_get_key (lua_State * L)
{
radix_tree_t *radix = lua_check_radix (L);
- uint32_t key;
+ guint32 key;
if (radix) {
key = luaL_checkint (L, 2);
return 1;
}
-static int
+static gint
lua_hash_table_get_key (lua_State * L)
{
GHashTable *tbl = lua_check_hash_table (L);
- const char *key;
+ const gchar *key;
if (tbl) {
key = luaL_checkstring (L, 2);
}
/* Trie functions */
-static int
+static gint
lua_trie_create (lua_State *L)
{
rspamd_trie_t *trie, **ptrie;
return 1;
}
-static int
+static gint
lua_trie_add_pattern (lua_State *L)
{
rspamd_trie_t *trie = lua_check_trie (L);
return 1;
}
-static int
+static gint
lua_trie_search_text (lua_State *L)
{
rspamd_trie_t *trie = lua_check_trie (L);
return 1;
}
-static int
+static gint
lua_trie_search_task (lua_State *L)
{
rspamd_trie_t *trie = lua_check_trie (L);
}
/* Init functions */
-int
+gint
luaopen_config (lua_State * L)
{
lua_newclass (L, "rspamd{config}", configlib_m);
return 1;
}
-int
+gint
luaopen_radix (lua_State * L)
{
lua_newclass (L, "rspamd{radix}", radixlib_m);
return 1;
}
-int
+gint
luaopen_hash_table (lua_State * L)
{
lua_newclass (L, "rspamd{hash_table}", hashlib_m);
return 1;
}
-int
+gint
luaopen_trie (lua_State * L)
{
lua_newclass (L, "rspamd{trie}", trielib_m);
#include "../message.h"
#define LUA_GMIME_BRIDGE_GET(class, name, mime_class) \
-static int \
+static gint \
lua_##class##_##name(lua_State *L) \
{ \
GMime##mime_class *obj = lua_check_##class(L); \
}
#define LUA_GMIME_BRIDGE_SET(class, name, mime_class) \
-static int \
+static gint \
lua_##class##_##name(lua_State *L) \
{ \
- const char *str; \
+ const gchar *str; \
GMime##mime_class *obj = lua_check_##class(L); \
if (obj != NULL) { \
str = luaL_checkstring (L, 2); \
LUA_GMIME_BRIDGE_GET (message, get_reply_to, Message)
LUA_GMIME_BRIDGE_SET (message, set_reply_to, Message)
-static int
+static gint
lua_message_get_header (lua_State * L)
{
- const char *headern;
+ const gchar *headern;
GMimeMessage *obj = lua_check_message (L);
GList *res = NULL, *cur;
- int i = 1;
+ gint i = 1;
if (obj != NULL) {
headern = luaL_checkstring (L, 2);
cur = res;
lua_newtable (L);
while (cur) {
- lua_pushstring (L, (const char *)cur->data);
+ lua_pushstring (L, (const gchar *)cur->data);
lua_rawseti (L, -2, i++);
g_free (cur->data);
cur = g_list_next (cur);
}
-static int
+static gint
lua_message_set_header (lua_State * L)
{
- const char *headern, *headerv;
+ const gchar *headern, *headerv;
GMimeMessage *obj = lua_check_message (L);
if (obj != NULL) {
}
-int
+gint
luaopen_message (lua_State * L)
{
lua_newclass (L, "rspamd{message}", msglib_m);
#include "../statfile_sync.h"
extern stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct classifier_config *ccf,
- const char *symbol, struct statfile **st, gboolean try_create);
+ const gchar *symbol, struct statfile **st, gboolean try_create);
/* Task methods */
LUA_FUNCTION_DEF (task, get_message);
}
/*** Task interface ***/
-static int
+static gint
lua_task_get_message (lua_State * L)
{
GMimeMessage **pmsg;
return 1;
}
-static int
+static gint
lua_task_insert_result (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
- const char *symbol_name, *param;
+ const gchar *symbol_name, *param;
double flag;
GList *params = NULL;
- int i, top;
+ gint i, top;
if (task != NULL) {
symbol_name = memory_pool_strdup (task->task_pool, luaL_checkstring (L, 2));
return 1;
}
-static int
+static gint
lua_task_get_urls (lua_State * L)
{
- int i = 1;
+ gint i = 1;
struct worker_task *task = lua_check_task (L);
GList *cur;
struct uri *url;
return 1;
}
-static int
+static gint
lua_task_get_text_parts (lua_State * L)
{
- int i = 1;
+ gint i = 1;
struct worker_task *task = lua_check_task (L);
GList *cur;
struct mime_text_part *part, **ppart;
return 1;
}
-static int
+static gint
lua_task_get_raw_headers (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
return 1;
}
-static int
+static gint
lua_task_get_received_headers (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
GList *cur;
struct received_header *rh;
- int i = 1;
+ gint i = 1;
if (task) {
lua_newtable (L);
struct lua_dns_callback_data {
lua_State *L;
struct worker_task *task;
- const char *callback;
- const char *to_resolve;
+ const gchar *callback;
+ const gchar *to_resolve;
};
static void
lua_dns_callback (struct rspamd_dns_reply *reply, gpointer arg)
{
struct lua_dns_callback_data *cd = arg;
- int i = 0;
+ gint i = 0;
struct in_addr ina;
struct worker_task **ptask;
union rspamd_reply_element *elt;
}
}
-static int
+static gint
lua_task_resolve_dns_a (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
return 0;
}
-static int
+static gint
lua_task_resolve_dns_txt (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
return 0;
}
-static int
+static gint
lua_task_resolve_dns_ptr (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
return 0;
}
-static int
+static gint
lua_task_call_rspamd_function (lua_State * L)
{
struct worker_task *task = lua_check_task (L);
struct expression_function f;
- int i, top;
+ gint i, top;
gboolean res;
- char *arg;
+ gchar *arg;
if (task) {
- f.name = (char *)luaL_checkstring (L, 2);
+ f.name = (gchar *)luaL_checkstring (L, 2);
if (f.name) {
f.args = NULL;
top = lua_gettop (L);
/* Get arguments after function name */
for (i = 3; i <= top; i++) {
- arg = (char *)luaL_checkstring (L, i);
+ arg = (gchar *)luaL_checkstring (L, i);
if (arg != NULL) {
f.args = g_list_prepend (f.args, arg);
}
}
-static int
+static gint
lua_task_get_recipients (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
- int i = 1;
+ gint i = 1;
GList *cur;
if (task) {
if (cur != NULL) {
lua_newtable (L);
while (cur) {
- lua_pushstring (L, (char *)cur->data);
+ lua_pushstring (L, (gchar *)cur->data);
lua_rawseti (L, -2, i++);
cur = g_list_next (cur);
}
return 1;
}
-static int
+static gint
lua_task_get_from (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
if (task) {
if (task->from != NULL) {
- lua_pushstring (L, (char *)task->from);
+ lua_pushstring (L, (gchar *)task->from);
return 1;
}
}
return 1;
}
-static int
+static gint
lua_task_get_from_ip (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
return 1;
}
-static int
+static gint
lua_task_get_from_ip_num (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
return 1;
}
-static int
+static gint
lua_task_get_client_ip_num (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
return 1;
}
-static int
+static gint
lua_task_get_helo (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
if (task) {
if (task->helo != NULL) {
- lua_pushstring (L, (char *)task->helo);
+ lua_pushstring (L, (gchar *)task->helo);
return 1;
}
}
return 1;
}
-static int
+static gint
lua_task_get_images (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
- int i = 1;
+ gint i = 1;
GList *cur;
struct rspamd_image **pimg;
}
G_INLINE_FUNC gboolean
-lua_push_symbol_result (lua_State *L, struct worker_task *task, struct metric *metric, const char *symbol)
+lua_push_symbol_result (lua_State *L, struct worker_task *task, struct metric *metric, const gchar *symbol)
{
struct metric_result *metric_res;
struct symbol *s;
- int j;
+ gint j;
GList *opt;
metric_res = g_hash_table_lookup (task->results, metric->name);
return FALSE;
}
-static int
+static gint
lua_task_get_symbol (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
- const char *symbol;
+ const gchar *symbol;
struct metric *metric;
GList *cur = NULL, *metric_list;
gboolean found = FALSE;
- int i = 1;
+ gint i = 1;
symbol = luaL_checkstring (L, 2);
return 1;
}
-static int
+static gint
lua_task_learn_statfile (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
- const char *symbol;
+ const gchar *symbol;
struct classifier_config *cl;
GTree *tokens;
struct statfile *st;
return 1;
}
-static int
+static gint
lua_task_get_metric_score (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
- const char *metric_name;
+ const gchar *metric_name;
struct metric_result *metric_res;
metric_name = luaL_checkstring (L, 2);
return 0;
}
-static int
+static gint
lua_task_get_metric_action (lua_State *L)
{
struct worker_task *task = lua_check_task (L);
- const char *metric_name;
+ const gchar *metric_name;
struct metric_result *metric_res;
enum rspamd_metric_action action;
/**** Textpart implementation *****/
-static int
+static gint
lua_textpart_get_content (lua_State * L)
{
struct mime_text_part *part = lua_check_textpart (L);
return 1;
}
-static int
+static gint
lua_textpart_is_empty (lua_State * L)
{
struct mime_text_part *part = lua_check_textpart (L);
return 1;
}
-static int
+static gint
lua_textpart_is_html (lua_State * L)
{
struct mime_text_part *part = lua_check_textpart (L);
return 1;
}
-static int
+static gint
lua_textpart_get_fuzzy (lua_State * L)
{
struct mime_text_part *part = lua_check_textpart (L);
}
/* Image functions */
-static int
+static gint
lua_image_get_width (lua_State *L)
{
struct rspamd_image *img = lua_check_image (L);
return 1;
}
-static int
+static gint
lua_image_get_height (lua_State *L)
{
struct rspamd_image *img = lua_check_image (L);
return 1;
}
-static int
+static gint
lua_image_get_type (lua_State *L)
{
struct rspamd_image *img = lua_check_image (L);
return 1;
}
-static int
+static gint
lua_image_get_size (lua_State *L)
{
struct rspamd_image *img = lua_check_image (L);
return 1;
}
-static int
+static gint
lua_image_get_filename (lua_State *L)
{
struct rspamd_image *img = lua_check_image (L);
}
/* Init part */
-int
+gint
luaopen_task (lua_State * L)
{
lua_newclass (L, "rspamd{task}", tasklib_m);
return 1;
}
-int
+gint
luaopen_textpart (lua_State * L)
{
lua_newclass (L, "rspamd{textpart}", textpartlib_m);
return 1;
}
-int
+gint
luaopen_image (lua_State * L)
{
lua_newclass (L, "rspamd{image}", imagelib_m);
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t *info, void *unused)
#endif
{
#ifdef HAVE_SA_SIGINFO
#ifdef HAVE_SA_SIGINFO
-static const char *
-chldsigcode (int code) {
+static const gchar *
+chldsigcode (gint code) {
switch (code) {
#ifdef CLD_EXITED
case CLD_EXITED:
inf->si_pid, chldsigcode (inf->si_code));
}
else {
- msg_info ("got signal: '%s'; received from pid: %P; uid: %l",
- g_strsignal (inf->si_signo), inf->si_pid, (long int)inf->si_uid);
+ msg_info ("got signal: '%s'; received from pid: %P; uid: %ul",
+ g_strsignal (inf->si_signo), inf->si_pid, (gulong)inf->si_uid);
}
g_free (inf);
}
static void
-read_cmd_line (int argc, char **argv, struct config_file *cfg)
+read_cmd_line (gint argc, gchar **argv, struct config_file *cfg)
{
GError *error = NULL;
GOptionContext *context;
exit (-errno);
}
if (setgid (grp->gr_gid) == -1) {
- msg_err ("cannot setgid to %d (%s), aborting", (int)grp->gr_gid, strerror (errno));
+ msg_err ("cannot setgid to %d (%s), aborting", (gint)grp->gr_gid, strerror (errno));
exit (-errno);
}
if (initgroups (cfg->rspamd_user, grp->gr_gid) == -1) {
}
}
if (setuid (pwd->pw_uid) == -1) {
- msg_err ("cannot setuid to %d (%s), aborting", (int)pwd->pw_uid, strerror (errno));
+ msg_err ("cannot setuid to %d (%s), aborting", (gint)pwd->pw_uid, strerror (errno));
exit (-errno);
}
}
reread_config (struct rspamd_main *rspamd)
{
struct config_file *tmp_cfg;
- char *cfg_file;
+ gchar *cfg_file;
GList *l;
struct filter *filt;
static void
dump_all_variables (gpointer key, gpointer value, gpointer data)
{
- printf ("$%s = \"%s\"\n", (char *)key, (char *)value);
+ printf ("$%s = \"%s\"\n", (gchar *)key, (gchar *)value);
}
g_hash_table_foreach (cfg->variables, dump_all_variables, NULL);
}
-static int
-create_listen_socket (struct in_addr *addr, int port, int family, char *path)
+static gint
+create_listen_socket (struct in_addr *addr, gint port, gint family, gchar *path)
{
- int listen_sock = -1;
+ gint listen_sock = -1;
struct sockaddr_un *un_addr;
/* Create listen socket */
if (family == AF_INET) {
}
static inline uintptr_t
-make_listen_key (struct in_addr *addr, int port, int family, char *path)
+make_listen_key (struct in_addr *addr, gint port, gint family, gchar *path)
{
uintptr_t res = 0;
- char *key;
+ gchar *key;
if (family == AF_INET) {
/* Make fnv hash from bytes of addr and port */
- key = (char *)&addr->s_addr;
- while (key - (char *)&addr->s_addr < sizeof (addr->s_addr)) {
- res ^= (char)*key++;
+ key = (gchar *)&addr->s_addr;
+ while (key - (gchar *)&addr->s_addr < sizeof (addr->s_addr)) {
+ res ^= (gchar)*key++;
res += (res << 1) + (res << 4) + (res << 7) + (res << 8) + (res << 24);
}
- key = (char *)&port;
- while (key - (char *)&port < sizeof (addr->s_addr)) {
- res ^= (char)*key++;
+ key = (gchar *)&port;
+ while (key - (gchar *)&port < sizeof (addr->s_addr)) {
+ res ^= (gchar)*key++;
res += (res << 1) + (res << 4) + (res << 7) + (res << 8) + (res << 24);
}
}
/* Make fnv hash from bytes of path */
key = path;
while (*key) {
- res ^= (char)*key++;
+ res ^= (gchar)*key++;
res += (res << 1) + (res << 4) + (res << 7) + (res << 8) + (res << 24);
}
}
{
GList *cur;
struct worker_conf *cf;
- int i, listen_sock;
+ gint i, listen_sock;
gpointer p;
cur = rspamd->cfg->workers;
}
}
-static const char *
+static const gchar *
get_process_type (enum process_type type)
{
switch (type) {
wait_for_workers (gpointer key, gpointer value, gpointer unused)
{
struct rspamd_worker *w = value;
- int res = 0;
+ gint res = 0;
waitpid (w->pid, &res, 0);
{
GList *cur;
struct cache_item *item;
- int i;
+ gint i;
if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg, cfg->cache_filename)) {
exit (EXIT_FAILURE);
}
}
-int
-main (int argc, char **argv, char **env)
+gint
+main (gint argc, gchar **argv, gchar **env)
{
struct rspamd_main *rspamd;
- int res = 0;
+ gint res = 0;
struct sigaction signals;
struct rspamd_worker *cur;
struct rlimit rlim;
* Server statistics
*/
struct rspamd_stat {
- unsigned int messages_scanned; /**< total number of messages scanned */
- unsigned int messages_spam; /**< messages treated as spam */
- unsigned int messages_ham; /**< messages treated as ham */
- unsigned int connections_count; /**< total connections count */
- unsigned int control_connections_count; /**< connections count to control interface */
- unsigned int messages_learned; /**< messages learned */
- unsigned int fuzzy_hashes; /**< number of fuzzy hashes stored */
- unsigned int fuzzy_hashes_expired; /**< number of fuzzy hashes expired */
+ guint messages_scanned; /**< total number of messages scanned */
+ guint messages_spam; /**< messages treated as spam */
+ guint messages_ham; /**< messages treated as ham */
+ 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 */
};
/**
/* Pid file structure */
struct pidfh *pfh; /**< struct pidfh for pidfile */
enum process_type type; /**< process type */
- unsigned int ev_initialized; /**< is event system is initialized */
+ guint ev_initialized; /**< is event system is initialized */
struct rspamd_stat *stat; /**< pointer to statistics */
memory_pool_t *server_pool; /**< server's memory pool */
};
struct counter_data {
- uint64_t value;
- int number;
+ guint64 value;
+ gint number;
};
/**
struct save_point {
GList *entry; /**< pointer to saved metric */
void *item; /**< pointer to saved item */
- unsigned int saved; /**< how much time we have delayed processing */
+ guint saved; /**< how much time we have delayed processing */
};
STATE_WAIT,
STATE_WEIGHTS
} state; /**< current session state */
- int sock; /**< socket descriptor */
+ gint sock; /**< socket descriptor */
/* Access to authorized commands */
- int authorized; /**< whether this session is authorized */
+ gint authorized; /**< whether this session is authorized */
memory_pool_t *session_pool; /**< memory pool for session */
struct config_file *cfg; /**< pointer to config file */
- char *learn_rcpt; /**< recipient for learning */
- char *learn_from; /**< from address for learning */
+ gchar *learn_rcpt; /**< recipient for learning */
+ gchar *learn_from; /**< from address for learning */
struct classifier_config *learn_classifier;
- char *learn_symbol; /**< symbol to train */
+ 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 */
- int in_class; /**< positive or negative learn */
+ gint in_class; /**< positive or negative learn */
void (*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 */
struct rspamd_async_session* s; /**< async session object */
};
-typedef void (*controller_func_t)(char **args, struct controller_session *session);
+typedef void (*controller_func_t)(gchar **args, struct controller_session *session);
/**
* Worker task structure
guint proto_ver; /**< protocol version */
enum rspamd_command cmd; /**< command */
struct custom_command *custom_cmd; /**< custom command if any */
- int sock; /**< socket descriptor */
+ gint sock; /**< socket descriptor */
gboolean is_mime; /**< if this task is mime task */
gboolean is_skipped; /**< whether message was skipped by configuration */
- char *helo; /**< helo header value */
- char *from; /**< from header value */
- char *queue_id; /**< queue id if specified */
- const char *message_id; /**< message id */
+ 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 */
- unsigned int nrcpt; /**< number of recipients */
+ guint nrcpt; /**< number of recipients */
struct in_addr from_addr; /**< client addr in numeric form */
struct in_addr client_addr; /**< client addr in numeric form */
- char *deliver_to; /**< address to deliver */
- char *user; /**< user to deliver */
- char *subject; /**< subject (for non-mime) */
+ gchar *deliver_to; /**< address to deliver */
+ gchar *user; /**< user to deliver */
+ gchar *subject; /**< subject (for non-mime) */
f_str_t *msg; /**< message buffer */
rspamd_io_dispatcher_t *dispatcher; /**< IO dispatcher object */
struct rspamd_async_session* s; /**< async session object */
- int parts_count; /**< mime parts count */
+ 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 */
- char *raw_headers; /**< list of raw headers */
+ gchar *raw_headers; /**< list of raw headers */
GList *received; /**< list of received headers */
GList *urls; /**< list of parsed urls */
GList *images; /**< list of images */
GHashTable *re_cache; /**< cache for matched or not matched regexps */
struct config_file *cfg; /**< pointer to config object */
struct save_point save; /**< save point for delayed processing */
- char *last_error; /**< last error */
- int error_code; /**< code of last error */
+ gchar *last_error; /**< last error */
+ gint error_code; /**< code of last error */
memory_pool_t *task_pool; /**< memory pool for task */
#ifdef HAVE_CLOCK_GETTIME
struct timespec ts; /**< time of connection */
struct rspamd_view *view; /**< matching view */
gboolean view_checked;
gboolean pass_all_filters; /**< pass task throught every rule */
- uint32_t parser_recursion; /**< for avoiding recursion stack overflow */
+ guint32 parser_recursion; /**< for avoiding recursion stack overflow */
gboolean (*fin_callback)(void *arg); /**< calback for filters finalizing */
void *fin_arg; /**< argument for fin callback */
* Common structure representing C module context
*/
struct module_ctx {
- int (*filter)(struct worker_task *task); /**< pointer to headers process function */
+ gint (*filter)(struct worker_task *task); /**< pointer to headers process function */
};
/**
* Common structure for C module
*/
struct c_module {
- const char *name; /**< name */
+ const gchar *name; /**< name */
struct module_ctx *ctx; /**< pointer to context */
};
/**
* Register custom controller function
*/
-void register_custom_controller_command (const char *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);
/**
* Construct new task for worker
static memory_pool_t *map_pool = NULL;
static GList *maps = NULL;
-static char *hash_fill = "1";
+static gchar *hash_fill = "1";
/* Http reply */
struct http_reply {
- int code;
+ gint code;
GHashTable *headers;
- char *cur_header;
+ gchar *cur_header;
- int parser_state;
+ gint parser_state;
};
struct http_callback_data {
struct http_reply *reply;
struct map_cb_data cbdata;
- int state;
- int fd;
+ gint state;
+ gint fd;
};
/* Value in seconds after whitch we would try to do stat on list file */
#define HTTP_CONNECT_TIMEOUT 2
#define HTTP_READ_TIMEOUT 10
-static int
+static gint
connect_http (struct rspamd_map *map, struct http_map_data *data, gboolean is_async)
{
- int sock;
+ gint sock;
if ((sock = make_tcp_socket (&data->addr, data->port, FALSE, is_async)) == -1) {
msg_info ("cannot connect to http server %s: %d, %s", data->host, errno, strerror (errno));
}
static void
-write_http_request (struct rspamd_map *map, struct http_map_data *data, int sock)
+write_http_request (struct rspamd_map *map, struct http_map_data *data, gint sock)
{
- char outbuf[BUFSIZ];
- int r;
+ gchar outbuf[BUFSIZ];
+ gint r;
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) {
}
else {
/* Try to parse HTTP reply code */
- reply->code = strtoul (++p, (char **)&err_str, 10);
+ reply->code = strtoul (++p, (gchar **)&err_str, 10);
if (*err_str != ' ') {
msg_info ("error while reading HTTP status code: %s", p);
return NULL;
return s;
}
-static int
+static gint
read_chunk_header (u_char * buf, size_t len, struct http_map_data *data)
{
u_char chunkbuf[32], *p, *c;
- int skip = 0;
+ gint skip = 0;
p = chunkbuf;
c = buf;
read_http_chunked (u_char * buf, size_t len, struct rspamd_map *map, struct http_map_data *data, struct map_cb_data *cbdata)
{
u_char *p = buf, *remain;
- uint32_t skip = 0;
+ guint32 skip = 0;
if (data->chunk == 0) {
/* Read first chunk data */
return TRUE;
}
else {
- msg_info ("invalid chunked reply: %*s", (int)len, buf);
+ msg_info ("invalid chunked reply: %*s", (gint)len, buf);
return FALSE;
}
}
}
static gboolean
-read_http_common (struct rspamd_map *map, struct http_map_data *data, struct http_reply *reply, struct map_cb_data *cbdata, int fd)
+read_http_common (struct rspamd_map *map, struct http_map_data *data, struct http_reply *reply, struct map_cb_data *cbdata, gint fd)
{
u_char *remain, *pos;
ssize_t r;
- char *te;
+ gchar *te;
if ((r = read (fd, data->read_buf + data->rlen, sizeof (data->read_buf) - data->rlen)) > 0) {
r += data->rlen;
read_http_sync (struct rspamd_map *map, struct http_map_data *data)
{
struct map_cb_data cbdata;
- int fd;
+ gint fd;
struct http_reply *repl;
if (map->read_callback == NULL || map->fin_callback == NULL) {
struct map_cb_data cbdata;
u_char buf[BUFSIZ], *remain;
ssize_t r;
- int fd, rlen;
+ gint fd, rlen;
if (map->read_callback == NULL || map->fin_callback == NULL) {
msg_err ("bad callback for reading map file");
}
gboolean
-add_map (const char *map_line, map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data)
+add_map (const gchar *map_line, map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data)
{
struct rspamd_map *new_map;
enum fetch_proto proto;
- const char *def, *p, *hostend;
+ const gchar *def, *p, *hostend;
struct file_map_data *fdata;
struct http_map_data *hdata;
- char portbuf[6];
- int i, s, fd;
+ gchar portbuf[6];
+ gint i, s, fd;
struct hostent *hent;
/* First of all detect protocol line */
{
radix_tree_t *tree = st;
- uint32_t mask = 0xFFFFFFFF;
- uint32_t ip;
- char *token, *ipnet, *err_str, **strv, **cur;
+ guint32 mask = 0xFFFFFFFF;
+ guint32 ip;
+ gchar *token, *ipnet, *err_str, **strv, **cur;
struct in_addr ina;
- int k;
+ gint k;
- strv = g_strsplit_set ((char *)key, " ,;", 0);
+ strv = g_strsplit_set ((gchar *)key, " ,;", 0);
cur = strv;
while (*cur) {
if (**cur == '\0') {
return;
}
- ip = ntohl ((uint32_t) ina.s_addr);
+ 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);
}
static void
-file_callback (int fd, short what, void *ud)
+file_callback (gint fd, short what, void *ud)
{
struct rspamd_map *map = ud;
struct file_map_data *data = map->map_data;
}
static void
-http_async_callback (int fd, short what, void *ud)
+http_async_callback (gint fd, short what, void *ud)
{
struct http_callback_data *cbd = ud;
static void
-http_callback (int fd, short what, void *ud)
+http_callback (gint fd, short what, void *ud)
{
struct rspamd_map *map = ud;
struct http_map_data *data = map->map_data;
- int sock;
+ gint sock;
struct http_callback_data *cbd;
/* Plan event again with jitter */
};
struct map_cb_data {
- int state;
+ gint state;
void *prev_data;
void *cur_data;
};
struct file_map_data {
- const char *filename;
+ const gchar *filename;
struct stat st;
};
struct http_map_data {
struct in_addr addr;
- uint16_t port;
- char *path;
- char *host;
+ guint16 port;
+ gchar *path;
+ gchar *host;
time_t last_checked;
gboolean chunked;
u_char read_buf[BUFSIZ];
- uint32_t rlen;
- uint32_t chunk;
- uint32_t chunk_read;
+ guint32 rlen;
+ guint32 chunk;
+ guint32 chunk_read;
};
typedef u_char* (*map_cb_t)(memory_pool_t *pool, u_char *chunk, size_t len, struct map_cb_data *data);
void *map_data;
};
-gboolean add_map (const char *map_line, map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data);
+gboolean add_map (const gchar *map_line, map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data);
void start_map_watch (void);
void remove_all_maps (void);
static memory_pool_stat_t *mem_pool_stat = NULL;
static struct _pool_chain *
-pool_chain_new (memory_pool_ssize_t size)
+pool_chain_new (gsize size)
{
struct _pool_chain *chain;
}
static struct _pool_chain_shared *
-pool_chain_new_shared (memory_pool_ssize_t size)
+pool_chain_new_shared (gsize size)
{
struct _pool_chain_shared *chain;
g_assert (chain != MAP_FAILED);
chain->begin = ((u_char *) chain) + sizeof (struct _pool_chain_shared);
#elif defined(HAVE_MMAP_ZERO)
- int fd;
+ gint fd;
fd = open ("/dev/zero", O_RDWR);
if (fd == -1) {
* @return new memory pool object
*/
memory_pool_t *
-memory_pool_new (memory_pool_ssize_t size)
+memory_pool_new (gsize size)
{
memory_pool_t *new;
mem_pool_stat = (memory_pool_stat_t *)mmap (NULL, sizeof (memory_pool_stat_t), PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
g_assert (stat != MAP_FAILED);
#elif defined(HAVE_MMAP_ZERO)
- int fd;
+ gint fd;
fd = open ("/dev/zero", O_RDWR);
g_assert (fd != -1);
}
void *
-memory_pool_alloc (memory_pool_t * pool, memory_pool_ssize_t size)
+memory_pool_alloc (memory_pool_t * pool, gsize size)
{
u_char *tmp;
struct _pool_chain *new, *cur;
}
void *
-memory_pool_alloc0 (memory_pool_t * pool, memory_pool_ssize_t size)
+memory_pool_alloc0 (memory_pool_t * pool, gsize size)
{
void *pointer = memory_pool_alloc (pool, size);
if (pointer) {
}
void *
-memory_pool_alloc0_shared (memory_pool_t * pool, memory_pool_ssize_t size)
+memory_pool_alloc0_shared (memory_pool_t * pool, gsize size)
{
void *pointer = memory_pool_alloc_shared (pool, size);
if (pointer) {
return pointer;
}
-char *
-memory_pool_strdup (memory_pool_t * pool, const char *src)
+gchar *
+memory_pool_strdup (memory_pool_t * pool, const gchar *src)
{
- memory_pool_ssize_t len;
- char *newstr;
+ gsize len;
+ gchar *newstr;
if (src == NULL) {
return NULL;
return newstr;
}
-char *
+gchar *
memory_pool_fstrdup (memory_pool_t * pool, const struct f_str_s *src)
{
- char *newstr;
+ gchar *newstr;
if (src == NULL) {
return NULL;
}
-char *
-memory_pool_strdup_shared (memory_pool_t * pool, const char *src)
+gchar *
+memory_pool_strdup_shared (memory_pool_t * pool, const gchar *src)
{
- memory_pool_ssize_t len;
- char *newstr;
+ gsize len;
+ gchar *newstr;
if (src == NULL) {
return NULL;
void *
-memory_pool_alloc_shared (memory_pool_t * pool, memory_pool_ssize_t size)
+memory_pool_alloc_shared (memory_pool_t * pool, gsize size)
{
u_char *tmp;
struct _pool_chain_shared *new, *cur;
return NULL;
}
-static inline int
+static inline gint
__mutex_spin (memory_pool_mutex_t * mutex)
{
/* check spin count */
/* By default allocate 8Kb chunks of memory */
#define FIXED_POOL_SIZE 8192
-memory_pool_ssize_t
+gsize
memory_pool_get_size ()
{
#ifdef HAVE_GETPAGESIZE
*/
typedef void (*pool_destruct_func)(void *ptr);
-/**
- * Type that represents allocating size
- */
-typedef long int memory_pool_ssize_t;
-
/**
* Pool mutex structure
*/
struct _pool_chain {
u_char *begin; /**< begin of pool chain block */
u_char *pos; /**< current start of free space in block */
- memory_pool_ssize_t len; /**< length of block */
+ gsize len; /**< length of block */
struct _pool_chain *next; /**< chain link */
};
struct _pool_chain_shared {
u_char *begin;
u_char *pos;
- memory_pool_ssize_t len;
+ gsize len;
memory_pool_mutex_t *lock;
struct _pool_chain_shared *next;
};
* Statistics structure
*/
typedef struct memory_pool_stat_s {
- memory_pool_ssize_t pools_allocated; /**< total number of allocated pools */
- memory_pool_ssize_t pools_freed; /**< number of freed pools */
- memory_pool_ssize_t bytes_allocated; /**< bytes that are allocated with pool allocator */
- memory_pool_ssize_t chunks_allocated; /**< number of chunks that are allocated */
- memory_pool_ssize_t shared_chunks_allocated; /**< shared chunks allocated */
- memory_pool_ssize_t chunks_freed; /**< chunks freed */
- memory_pool_ssize_t 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 */
} memory_pool_stat_t;
/**
* @param size size of pool's page
* @return new memory pool object
*/
-memory_pool_t* memory_pool_new (memory_pool_ssize_t size);
+memory_pool_t* memory_pool_new (gsize size);
/**
* Get memory from pool
* @param size bytes to allocate
* @return pointer to allocated object
*/
-void* memory_pool_alloc (memory_pool_t* pool, memory_pool_ssize_t size);
+void* memory_pool_alloc (memory_pool_t* pool, gsize size);
/**
* Get memory and set it to zero
* @param size bytes to allocate
* @return pointer to allocated object
*/
-void* memory_pool_alloc0 (memory_pool_t* pool, memory_pool_ssize_t size);
+void* memory_pool_alloc0 (memory_pool_t* pool, gsize size);
/**
* Make a copy of string in pool
* @param src source string
* @return pointer to newly created string that is copy of src
*/
-char* memory_pool_strdup (memory_pool_t* pool, const char *src);
+gchar* memory_pool_strdup (memory_pool_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
*/
-char* memory_pool_fstrdup (memory_pool_t* pool, const struct f_str_s *src);
+gchar* memory_pool_fstrdup (memory_pool_t* pool, const struct f_str_s *src);
/**
* Allocate piece of shared memory
* @param pool memory pool object
* @param size bytes to allocate
*/
-void* memory_pool_alloc_shared (memory_pool_t *pool, memory_pool_ssize_t size);
-void* memory_pool_alloc0_shared (memory_pool_t *pool, memory_pool_ssize_t size);
-char* memory_pool_strdup_shared (memory_pool_t* pool, const char *src);
+void* memory_pool_alloc_shared (memory_pool_t *pool, gsize size);
+void* memory_pool_alloc0_shared (memory_pool_t *pool, gsize size);
+gchar* memory_pool_strdup_shared (memory_pool_t* pool, const gchar *src);
/**
* Lock chunk of shared memory in which pointer is placed
* Get optimal pool size based on page size for this system
* @return size of memory page in system
*/
-memory_pool_ssize_t memory_pool_get_size ();
+gsize memory_pool_get_size ();
/**
* Set memory pool variable
static void
test_memc_callback (memcached_ctx_t * ctx, memc_error_t error, void *data)
{
- int s;
- int r;
- int *num = ((int *)data);
+ gint s;
+ gint r;
+ gint *num = ((gint *)data);
printf ("result of memc command '%s' is '%s'\n", ctx->cmd, memc_strerror (error));
/* Connect */
if (*num == 0) {
- printf ("Setting value to memcached: %s -> %s\n", cur_param.key, (char *)cur_param.buf);
+ printf ("Setting value to memcached: %s -> %s\n", cur_param.key, (gchar *)cur_param.buf);
s = 1;
r = memc_set (ctx, &cur_param, &s, 60);
(*num)++;
}
else if (*num == 1) {
- printf ("Getting value from memcached: %s -> %s\n", cur_param.key, (char *)cur_param.buf);
+ printf ("Getting value from memcached: %s -> %s\n", cur_param.key, (gchar *)cur_param.buf);
s = 1;
r = memc_get (ctx, &cur_param, &s);
(*num)++;
}
else {
- printf ("Got value from memcached: %s -> %s\n", cur_param.key, (char *)cur_param.buf);
+ printf ("Got value from memcached: %s -> %s\n", cur_param.key, (gchar *)cur_param.buf);
event_loopexit (NULL);
}
}
-int
-main (int argc, char **argv)
+gint
+main (gint argc, gchar **argv)
{
memcached_ctx_t mctx;
- char *addr, buf[512];
- int num = 0;
+ gchar *addr, buf[512];
+ gint num = 0;
event_init ();
strcpy (cur_param.key, "testkey");
/* Header for udp protocol */
struct memc_udp_header {
- uint16_t req_id;
- uint16_t seq_num;
- uint16_t dg_sent;
- uint16_t unused;
+ guint16 req_id;
+ guint16 seq_num;
+ guint16 dg_sent;
+ guint16 unused;
};
-static void socket_callback (int fd, short what, void *arg);
-static int memc_parse_header (char *buf, size_t * len, char **end);
+static void socket_callback (gint fd, short what, void *arg);
+static gint memc_parse_header (gchar *buf, size_t * len, gchar **end);
/*
* Write to syslog if OPT_DEBUG is specified
*/
static void
-memc_log (const memcached_ctx_t * ctx, int line, const char *fmt, ...)
+memc_log (const memcached_ctx_t * ctx, gint line, const gchar *fmt, ...)
{
va_list args;
if (ctx->options & MEMC_OPT_DEBUG) {
* Callback for write command
*/
static void
-write_handler (int fd, short what, memcached_ctx_t * ctx)
+write_handler (gint fd, short what, memcached_ctx_t * ctx)
{
- char read_buf[READ_BUFSIZ];
- int retries;
+ gchar read_buf[READ_BUFSIZ];
+ gint retries;
ssize_t r;
struct memc_udp_header header;
struct iovec iov[4];
* Callback for read command
*/
static void
-read_handler (int fd, short what, memcached_ctx_t * ctx)
+read_handler (gint fd, short what, memcached_ctx_t * ctx)
{
- char read_buf[READ_BUFSIZ];
- char *p;
+ gchar read_buf[READ_BUFSIZ];
+ gchar *p;
ssize_t r;
size_t datalen;
struct memc_udp_header header;
struct iovec iov[2];
- int retries = 0, t;
+ gint retries = 0, t;
if (what == EV_WRITE) {
/* Send command to memcached */
* Callback for delete command
*/
static void
-delete_handler (int fd, short what, memcached_ctx_t * ctx)
+delete_handler (gint fd, short what, memcached_ctx_t * ctx)
{
- char read_buf[READ_BUFSIZ];
- int retries;
+ gchar read_buf[READ_BUFSIZ];
+ gint retries;
ssize_t r;
struct memc_udp_header header;
struct iovec iov[2];
* Callback for our socket events
*/
static void
-socket_callback (int fd, short what, void *arg)
+socket_callback (gint fd, short what, void *arg)
{
memcached_ctx_t *ctx = (memcached_ctx_t *) arg;
/*
* Make socket for udp connection
*/
-static int
+static gint
memc_make_udp_sock (memcached_ctx_t * ctx)
{
struct sockaddr_in sc;
- int ofl;
+ gint ofl;
bzero (&sc, sizeof (struct sockaddr_in *));
sc.sin_family = AF_INET;
/*
* Make socket for tcp connection
*/
-static int
+static gint
memc_make_tcp_sock (memcached_ctx_t * ctx)
{
struct sockaddr_in sc;
- int ofl, r;
+ gint ofl, r;
bzero (&sc, sizeof (struct sockaddr_in *));
sc.sin_family = AF_INET;
/*
* Parse VALUE reply from server and set len argument to value returned by memcached
*/
-static int
-memc_parse_header (char *buf, size_t * len, char **end)
+static gint
+memc_parse_header (gchar *buf, size_t * len, gchar **end)
{
- char *p, *c;
- int i;
+ gchar *p, *c;
+ gint i;
/* VALUE <key> <flags> <bytes> [<cas unique>]\r\n */
c = strstr (buf, CRLF);
* Common read command handler for memcached
*/
memc_error_t
-memc_read (memcached_ctx_t * ctx, const char *cmd, memcached_param_t * param)
+memc_read (memcached_ctx_t * ctx, const gchar *cmd, memcached_param_t * param)
{
ctx->cmd = cmd;
ctx->op = CMD_READ;
* Common write command handler for memcached
*/
memc_error_t
-memc_write (memcached_ctx_t * ctx, const char *cmd, memcached_param_t * param, int expire)
+memc_write (memcached_ctx_t * ctx, const gchar *cmd, memcached_param_t * param, gint expire)
{
ctx->cmd = cmd;
ctx->op = CMD_WRITE;
* writing is done to each memcached server
*/
memc_error_t
-memc_write_mirror (memcached_ctx_t * ctx, size_t memcached_num, const char *cmd, memcached_param_t * param, int expire)
+memc_write_mirror (memcached_ctx_t * ctx, size_t memcached_num, const gchar *cmd, memcached_param_t * param, gint expire)
{
memc_error_t r, result = OK;
* reading is done from first active memcached server
*/
memc_error_t
-memc_read_mirror (memcached_ctx_t * ctx, size_t memcached_num, const char *cmd, memcached_param_t * param)
+memc_read_mirror (memcached_ctx_t * ctx, size_t memcached_num, const gchar *cmd, memcached_param_t * param)
{
memc_error_t r, result = OK;
* deleting is done for each active memcached server
*/
memc_error_t
-memc_delete_mirror (memcached_ctx_t * ctx, size_t memcached_num, const char *cmd, memcached_param_t * param)
+memc_delete_mirror (memcached_ctx_t * ctx, size_t memcached_num, const gchar *cmd, memcached_param_t * param)
{
memc_error_t r, result = OK;
/*
* Initialize memcached context for specified protocol
*/
-int
+gint
memc_init_ctx (memcached_ctx_t * ctx)
{
if (ctx == NULL) {
/*
* Mirror init
*/
-int
+gint
memc_init_ctx_mirror (memcached_ctx_t * ctx, size_t memcached_num)
{
- int r, result = -1;
+ gint r, result = -1;
while (memcached_num--) {
if (ctx[memcached_num].alive == 1) {
r = memc_init_ctx (&ctx[memcached_num]);
/*
* Close context connection
*/
-int
+gint
memc_close_ctx (memcached_ctx_t * ctx)
{
if (ctx != NULL && ctx->sock != -1) {
/*
* Mirror close
*/
-int
+gint
memc_close_ctx_mirror (memcached_ctx_t * ctx, size_t memcached_num)
{
- int r = 0;
+ gint r = 0;
while (memcached_num--) {
if (ctx[memcached_num].alive == 1) {
r = memc_close_ctx (&ctx[memcached_num]);
}
-const char *
+const gchar *
memc_strerror (memc_error_t err)
{
- const char *p;
+ const gchar *p;
switch (err) {
case OK:
} memc_opt_t;
typedef struct memcached_param_s {
- char key[MAXKEYLEN];
+ gchar key[MAXKEYLEN];
u_char *buf;
size_t bufsize;
size_t bufpos;
- int expire;
+ gint expire;
} memcached_param_t;
typedef struct memcached_ctx_s {
memc_proto_t protocol;
struct in_addr addr;
- uint16_t port;
- int sock;
+ guint16 port;
+ gint sock;
struct timeval timeout;
/* Counter that is used for memcached operations in network byte order */
- uint16_t count;
+ guint16 count;
/* Flag that signalize that this memcached is alive */
short alive;
/* Options that can be specified for memcached connection */
/* Current operation */
memc_opt_t op;
/* Current command */
- const char *cmd;
+ const gchar *cmd;
/* Current param */
memcached_param_t *param;
/* Callback for current operation */
* 0 - success
* -1 - error (error is stored in errno)
*/
-int memc_init_ctx (memcached_ctx_t *ctx);
-int memc_init_ctx_mirror (memcached_ctx_t *ctx, size_t memcached_num);
+gint memc_init_ctx (memcached_ctx_t *ctx);
+gint memc_init_ctx_mirror (memcached_ctx_t *ctx, size_t memcached_num);
/*
* Memcached function for getting, setting, adding values to memcached server
* ctx - valid memcached context
#define memc_prepend_mirror(ctx, num, param, expire) memc_write_mirror(ctx, num, "prepend", param, expire)
-memc_error_t memc_read (memcached_ctx_t *ctx, const char *cmd, memcached_param_t *param);
-memc_error_t memc_write (memcached_ctx_t *ctx, const char *cmd, memcached_param_t *param, int expire);
+memc_error_t memc_read (memcached_ctx_t *ctx, const gchar *cmd, memcached_param_t *param);
+memc_error_t memc_write (memcached_ctx_t *ctx, const gchar *cmd, memcached_param_t *param, gint expire);
memc_error_t memc_delete (memcached_ctx_t *ctx, memcached_param_t *params);
-memc_error_t memc_write_mirror (memcached_ctx_t *ctx, size_t memcached_num, const char *cmd, memcached_param_t *param, int expire);
-memc_error_t memc_read_mirror (memcached_ctx_t *ctx, size_t memcached_num, const char *cmd, memcached_param_t *param);
-memc_error_t memc_delete_mirror (memcached_ctx_t *ctx, size_t memcached_num, const char *cmd, memcached_param_t *param);
+memc_error_t memc_write_mirror (memcached_ctx_t *ctx, size_t memcached_num, const gchar *cmd, memcached_param_t *param, gint expire);
+memc_error_t memc_read_mirror (memcached_ctx_t *ctx, size_t memcached_num, const gchar *cmd, memcached_param_t *param);
+memc_error_t memc_delete_mirror (memcached_ctx_t *ctx, size_t memcached_num, const gchar *cmd, memcached_param_t *param);
/* Return symbolic name of memcached error*/
-const char * memc_strerror (memc_error_t err);
+const gchar * memc_strerror (memc_error_t err);
/* Destroy socket from ctx */
-int memc_close_ctx (memcached_ctx_t *ctx);
-int memc_close_ctx_mirror (memcached_ctx_t *ctx, size_t memcached_num);
+gint memc_close_ctx (memcached_ctx_t *ctx);
+gint memc_close_ctx_mirror (memcached_ctx_t *ctx, size_t memcached_num);
#endif
#define UTF8_CHARSET "UTF-8"
GByteArray *
-strip_html_tags (struct worker_task *task, memory_pool_t * pool, struct mime_text_part *part, GByteArray * src, int *stateptr)
+strip_html_tags (struct worker_task *task, memory_pool_t * pool, struct mime_text_part *part, GByteArray * src, gint *stateptr)
{
uint8_t *tbuf = NULL, *p, *tp = NULL, *rp, *tbegin = NULL, c, lc;
- int br, i = 0, depth = 0, in_q = 0;
- int state = 0;
+ gint br, i = 0, depth = 0, in_q = 0;
+ gint state = 0;
GByteArray *buf;
GNode *level_ptr = NULL;
}
static void
-parse_qmail_recv (memory_pool_t * pool, char *line, struct received_header *r)
+parse_qmail_recv (memory_pool_t * pool, gchar *line, struct received_header *r)
{
- char *s, *p, t;
+ gchar *s, *p, t;
/* We are intersted only with received from network headers */
if ((p = strstr (line, "from network")) == NULL) {
}
static void
-parse_recv_header (memory_pool_t * pool, char *line, struct received_header *r)
+parse_recv_header (memory_pool_t * pool, gchar *line, struct received_header *r)
{
- char *p, *s, t, **res = NULL;
- int state = 0, next_state = 0;
+ gchar *p, *s, t, **res = NULL;
+ gint state = 0, next_state = 0;
g_strstrip (line);
p = line;
{
GError *err = NULL;
gsize read_bytes, write_bytes;
- const char *charset;
+ const gchar *charset;
gchar *res_str;
GByteArray *result_array;
GMimeObject *part, GMimeObject *parent, gboolean is_empty)
{
struct mime_text_part *text_part;
- const char *cd;
+ const gchar *cd;
/* Skip attachements */
#ifndef GMIME24
g_object_unref (msg);
}
-int
+gint
process_message (struct worker_task *task)
{
GMimeMessage *message;
GMimePart *part;
GMimeDataWrapper *wrapper;
struct received_header *recv;
- char *mid;
+ gchar *mid;
tmp = memory_pool_alloc (task->task_pool, sizeof (GByteArray));
tmp->data = task->msg->begin;
if (task->is_mime) {
- debug_task ("construct mime parser from string length %d", (int)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);
if (task->rcpt) {
cur = task->rcpt;
while (cur) {
- g_mime_message_add_recipient (task->message, GMIME_RECIPIENT_TYPE_TO, NULL, (char *)cur->data);
+ g_mime_message_add_recipient (task->message, GMIME_RECIPIENT_TYPE_TO, NULL, (gchar *)cur->data);
cur = g_list_next (cur);
}
}
struct raw_header {
struct raw_header *next;
- char *name;
- char *value;
+ gchar *name;
+ gchar *value;
};
typedef struct _GMimeHeader {
#ifndef GMIME24
static void
-header_iterate (memory_pool_t * pool, struct raw_header *h, GList ** ret, const char *field)
+header_iterate (memory_pool_t * pool, struct raw_header *h, GList ** ret, const gchar *field)
{
while (h) {
if (h->value && !g_strncasecmp (field, h->name, strlen (field))) {
}
#else
static void
-header_iterate (memory_pool_t * pool, GMimeHeaderList * ls, GList ** ret, const char *field)
+header_iterate (memory_pool_t * pool, GMimeHeaderList * ls, GList ** ret, const gchar *field)
{
GMimeHeaderIter *iter;
- const char *name;
+ const gchar *name;
if (ls == NULL) {
*ret = NULL;
struct multipart_cb_data {
GList *ret;
memory_pool_t *pool;
- const char *field;
+ const gchar *field;
gboolean try_search;
- int rec;
+ gint rec;
};
#define MAX_REC 10
}
static GList *
-local_message_get_header (memory_pool_t * pool, GMimeMessage * message, const char *field)
+local_message_get_header (memory_pool_t * pool, GMimeMessage * message, const gchar *field)
{
GList *gret = NULL;
GMimeObject *part;
local_mime_message_set_date_from_string (GMimeMessage * message, const gchar * string)
{
time_t date;
- int offset = 0;
+ 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 char *
+static const gchar *
local_message_get_sender (GMimeMessage * message)
{
- char *res;
- const char *from = g_mime_message_get_sender (message);
+ gchar *res;
+ const gchar *from = g_mime_message_get_sender (message);
InternetAddressList *ia;
#ifndef GMIME24
return res;
}
-static const char *
+static const gchar *
local_message_get_reply_to (GMimeMessage * message)
{
- char *res;
- const char *from = g_mime_message_get_reply_to (message);
+ gchar *res;
+ const gchar *from = g_mime_message_get_reply_to (message);
InternetAddressList *ia;
#ifndef GMIME24
ADD_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
# define GET_RECIPIENT_TEMPLATE(type,def) \
static InternetAddressList* \
-local_message_get_recipients_##type (GMimeMessage *message, const char *unused) \
+local_message_get_recipients_##type (GMimeMessage *message, const gchar *unused) \
{ \
return g_mime_message_get_recipients (message, (def)); \
}
GET_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
#endif
/* different declarations for different types of set and get functions */
- typedef const char *(*GetFunc) (GMimeMessage * message);
- typedef InternetAddressList *(*GetRcptFunc) (GMimeMessage * message, const char *type);
- typedef GList *(*GetListFunc) (memory_pool_t * pool, GMimeMessage * message, const char *type);
- typedef void (*SetFunc) (GMimeMessage * message, const char *value);
- typedef void (*SetListFunc) (GMimeMessage * message, const char *field, const char *value);
+ typedef const gchar *(*GetFunc) (GMimeMessage * message);
+ typedef InternetAddressList *(*GetRcptFunc) (GMimeMessage * message, const gchar *type);
+ typedef GList *(*GetListFunc) (memory_pool_t * pool, GMimeMessage * message, const gchar *type);
+ 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 char*
+* - get returns gchar*
*
* FUNC_IA (from Internet Address)
* - function with additional "field" argument from the fieldfunc table,
* functions.
**/
static struct {
- char *name;
+ gchar *name;
GetFunc func;
GetRcptFunc rcptfunc;
GetListFunc getlistfunc;
* message_set_header: set header of any type excluding special (Content- and MIME-Version:)
**/
void
-message_set_header (GMimeMessage * message, const char *field, const char *value)
+message_set_header (GMimeMessage * message, const gchar *field, const gchar *value)
{
gint i;
* You should free the GList list by yourself.
**/
GList *
-message_get_header (memory_pool_t * pool, GMimeMessage * message, const char *field)
+message_get_header (memory_pool_t * pool, GMimeMessage * message, const gchar *field)
{
gint i;
- char *ret = NULL, *ia_string;
+ gchar *ret = NULL, *ia_string;
GList *gret = NULL;
InternetAddressList *ia_list = NULL, *ia;
if (!fieldfunc[i].name || !g_strncasecmp (field, fieldfunc[i].name, strlen (fieldfunc[i].name))) {
switch (fieldfunc[i].functype) {
case FUNC_CHARFREEPTR:
- ret = (char *)(*(fieldfunc[i].func)) (message);
+ ret = (gchar *)(*(fieldfunc[i].func)) (message);
break;
case FUNC_CHARPTR:
- ret = (char *)(*(fieldfunc[i].func)) (message);
+ ret = (gchar *)(*(fieldfunc[i].func)) (message);
break;
case FUNC_IA:
ia_list = (*(fieldfunc[i].rcptfunc)) (message, field);
GByteArray *content;
GMimeObject *parent;
gchar *checksum;
- const char *filename;
+ const gchar *filename;
};
struct mime_text_part {
};
struct received_header {
- char *from_hostname;
- char *from_ip;
- char *real_hostname;
- char *real_ip;
- char *by_hostname;
- int is_error;
+ gchar *from_hostname;
+ gchar *from_ip;
+ gchar *real_hostname;
+ gchar *real_ip;
+ gchar *by_hostname;
+ gint is_error;
};
/**
* @param task worker_task object
* @return 0 if we have delayed filters to process and 1 if we have finished with processing
*/
-int process_message (struct worker_task *task);
+gint process_message (struct worker_task *task);
-void message_set_header (GMimeMessage *message, const char *field, const char *value);
-GList* message_get_header (memory_pool_t *pool, GMimeMessage *message, const char *field);
+void message_set_header (GMimeMessage *message, const gchar *field, const gchar *value);
+GList* message_get_header (memory_pool_t *pool, GMimeMessage *message, const gchar *field);
#endif
init_perl_filters (struct config_file *cfg)
{
struct perl_module *module;
- char *init_func;
+ gchar *init_func;
size_t funclen;
SV *sv;
}
-int
-perl_call_header_filter (const char *function, struct worker_task *task)
+gint
+perl_call_header_filter (const gchar *function, struct worker_task *task)
{
- int result;
+ gint result;
SV *sv;
dTHXa (perl_interpreter);
return result;
}
-int
-perl_call_chain_filter (const char *function, struct worker_task *task, int *marks, unsigned int number)
+gint
+perl_call_chain_filter (const gchar *function, struct worker_task *task, gint *marks, guint number)
{
- int result, i;
+ gint result, i;
AV *av;
SV *sv;
struct consolidation_callback_data {
struct worker_task *task;
double score;
- const char *func;
+ const gchar *func;
};
static void
PUSHMARK (SP);
- XPUSHs (sv_2mortal (newSVpv ((const char *)key, 0)));
+ XPUSHs (sv_2mortal (newSVpv ((const gchar *)key, 0)));
XPUSHs (sv_2mortal (newSVnv (s->score)));
PUTBACK;
}
double
-perl_consolidation_func (struct worker_task *task, const char *metric_name, const char *function_name)
+perl_consolidation_func (struct worker_task *task, const gchar *metric_name, const gchar *function_name)
{
struct metric_result *metric_res;
double res = 0.;
void init_perl_filters (struct config_file *cfg);
-int perl_call_filter (const char *function, struct worker_task *task);
-int perl_call_chain_filter (const char *function, struct worker_task *task, int *marks, unsigned int number);
+gint perl_call_filter (const gchar *function, struct worker_task *task);
+gint perl_call_chain_filter (const gchar *function, struct worker_task *task, gint *marks, guint number);
void perl_call_memcached_callback (memcached_ctx_t *ctx, memc_error_t error, void *data);
-double perl_consolidation_func (struct worker_task *task, const char *metric_name, const char *function_name);
+double perl_consolidation_func (struct worker_task *task, const gchar *metric_name, const gchar *function_name);
#endif
#define DEFAULT_THRESHOLD 0.1
struct chartable_ctx {
- int (*filter) (struct worker_task * task);
- char *symbol;
+ gint (*filter) (struct worker_task * task);
+ gchar *symbol;
double threshold;
memory_pool_t *chartable_pool;
static struct chartable_ctx *chartable_module_ctx = NULL;
-static int chartable_mime_filter (struct worker_task *task);
+static gint chartable_mime_filter (struct worker_task *task);
static void chartable_symbol_callback (struct worker_task *task, void *unused);
-int
+gint
chartable_module_init (struct config_file *cfg, struct module_ctx **ctx)
{
chartable_module_ctx = g_malloc (sizeof (struct chartable_ctx));
}
-int
+gint
chartable_module_config (struct config_file *cfg)
{
- char *value;
- int res = TRUE;
+ gchar *value;
+ gint res = TRUE;
if ((value = get_module_opt (cfg, "chartable", "symbol")) != NULL) {
chartable_module_ctx->symbol = memory_pool_strdup (chartable_module_ctx->chartable_pool, value);
return res;
}
-int
+gint
chartable_module_reconfig (struct config_file *cfg)
{
memory_pool_delete (chartable_module_ctx->chartable_pool);
static gboolean
check_part (struct mime_text_part *part, gboolean raw_mode)
{
- unsigned char *p, *p1;
+ guchar *p, *p1;
gunichar c, t;
GUnicodeScript scc, sct;
- uint32_t mark = 0, total = 0;
- uint32_t remain = part->content->len;
+ guint32 mark = 0, total = 0;
+ guint32 remain = part->content->len;
p = part->content->data;
}
-static int
+static gint
chartable_mime_filter (struct worker_task *task)
{
/* XXX: remove it */
#define DEFAULT_SYMBOL "R_BAD_EMAIL"
-static const char *email_re_text =
+static const gchar *email_re_text =
"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\\b";
struct email_ctx {
- int (*filter) (struct worker_task * task);
- char *symbol;
+ gint (*filter) (struct worker_task * task);
+ gchar *symbol;
GRegex *email_re;
GHashTable *blacklist;
- char *blacklist_file;
+ gchar *blacklist_file;
memory_pool_t *email_pool;
};
static struct email_ctx *email_module_ctx = NULL;
-static int emails_mime_filter (struct worker_task *task);
+static gint emails_mime_filter (struct worker_task *task);
static void emails_symbol_callback (struct worker_task *task, void *unused);
-static int emails_command_handler (struct worker_task *task);
+static gint emails_command_handler (struct worker_task *task);
-int
+gint
emails_module_init (struct config_file *cfg, struct module_ctx **ctx)
{
GError *err = NULL;
}
-int
+gint
emails_module_config (struct config_file *cfg)
{
- char *value;
- int res = TRUE;
+ gchar *value;
+ gint res = TRUE;
if ((value = get_module_opt (cfg, "emails", "symbol")) != NULL) {
email_module_ctx->symbol = memory_pool_strdup (email_module_ctx->email_pool, value);
return res;
}
-int
+gint
emails_module_reconfig (struct config_file *cfg)
{
memory_pool_delete (email_module_ctx->email_pool);
GMatchInfo *info;
GError *err = NULL;
struct mime_text_part *part;
- char *email_str;
- int rc;
+ gchar *email_str;
+ gint rc;
cur = g_list_first (task->text_parts);
while (cur) {
continue;
}
- rc = g_regex_match_full (email_module_ctx->email_re, (const char *)part->orig->data, part->orig->len, 0, 0, &info, &err);
+ rc = g_regex_match_full (email_module_ctx->email_re, (const gchar *)part->orig->data, part->orig->len, 0, 0, &info, &err);
if (rc) {
while (g_match_info_matches (info)) {
email_str = g_match_info_fetch (info, 0);
return res;
}
-static int
+static gint
emails_command_handler (struct worker_task *task)
{
GList *emails, *cur;
- char outbuf[BUFSIZ];
- int r, num = 0;
+ gchar outbuf[BUFSIZ];
+ gint r, num = 0;
emails = extract_emails (task);
while (cur) {
num++;
if (g_list_next (cur) != NULL) {
- r += snprintf (outbuf + r, sizeof (outbuf) - r - 2, "%s, ", (char *)cur->data);
+ r += snprintf (outbuf + r, sizeof (outbuf) - r - 2, "%s, ", (gchar *)cur->data);
}
else {
- r += snprintf (outbuf + r, sizeof (outbuf) - r - 2, "%s", (char *)cur->data);
+ r += snprintf (outbuf + r, sizeof (outbuf) - r - 2, "%s", (gchar *)cur->data);
}
cur = g_list_next (cur);
}
while (cur) {
if (g_hash_table_lookup (email_module_ctx->blacklist, cur->data) != NULL) {
- insert_result (task, email_module_ctx->symbol, 1, g_list_prepend (NULL, memory_pool_strdup (task->task_pool, (char *)cur->data)));
+ insert_result (task, email_module_ctx->symbol, 1, g_list_prepend (NULL, memory_pool_strdup (task->task_pool, (gchar *)cur->data)));
}
cur = g_list_next (cur);
}
-static int
+static gint
emails_mime_filter (struct worker_task *task)
{
/* XXX: remove this */
struct storage_server {
struct upstream up;
- char *name;
+ gchar *name;
struct in_addr addr;
- uint16_t port;
+ guint16 port;
};
struct fuzzy_mapping {
- uint32_t fuzzy_flag;
- char *symbol;
+ guint32 fuzzy_flag;
+ gchar *symbol;
double weight;
};
struct fuzzy_mime_type {
- char *type;
- char *subtype;
+ gchar *type;
+ gchar *subtype;
};
struct fuzzy_ctx {
- int (*filter) (struct worker_task * task);
- char *symbol;
+ gint (*filter) (struct worker_task * task);
+ gchar *symbol;
struct storage_server *servers;
- int servers_num;
+ gint servers_num;
memory_pool_t *fuzzy_pool;
double max_score;
gint32 min_hash_len;
};
struct fuzzy_client_session {
- int state;
+ gint state;
fuzzy_hash_t *h;
struct event ev;
struct timeval tv;
struct worker_task *task;
struct storage_server *server;
- int fd;
+ gint fd;
};
struct fuzzy_learn_session {
struct event ev;
fuzzy_hash_t *h;
- int cmd;
- int value;
- int flag;
- int *saved;
+ gint cmd;
+ gint value;
+ gint flag;
+ gint *saved;
struct timeval tv;
struct controller_session *session;
struct storage_server *server;
struct worker_task *task;
- int fd;
+ gint fd;
};
static struct fuzzy_ctx *fuzzy_module_ctx = NULL;
static const gchar hex_digits[] = "0123456789abcdef";
-static int fuzzy_mime_filter (struct worker_task *task);
+static gint fuzzy_mime_filter (struct worker_task *task);
static void fuzzy_symbol_callback (struct worker_task *task, void *unused);
-static void fuzzy_add_handler (char **args, struct controller_session *session);
-static void fuzzy_delete_handler (char **args, struct controller_session *session);
+static void fuzzy_add_handler (gchar **args, struct controller_session *session);
+static void fuzzy_delete_handler (gchar **args, struct controller_session *session);
/* Flags string is in format <numeric_flag>:<SYMBOL>:weight[, <numeric_flag>:<SYMBOL>:weight...] */
static void
-parse_flags_string (char *str)
+parse_flags_string (gchar *str)
{
- char **strvec, *item, *err_str, **map_str;
- int num, i, t;
+ gchar **strvec, *item, *err_str, **map_str;
+ gint num, i, t;
struct fuzzy_mapping *map;
strvec = g_strsplit_set (str, ", ;", 0);
}
static GList *
-parse_mime_types (const char *str)
+parse_mime_types (const gchar *str)
{
- char **strvec, *p;
- int num, i;
+ gchar **strvec, *p;
+ gint num, i;
struct fuzzy_mime_type *type;
GList *res = NULL;
}
static void
-parse_servers_string (char *str)
+parse_servers_string (gchar *str)
{
- char **strvec, *p, portbuf[6], *name;
- int num, i, j, port;
+ gchar **strvec, *p, portbuf[6], *name;
+ gint num, i, j, port;
struct hostent *hent;
struct in_addr addr;
}
static double
-fuzzy_normalize (int32_t in, double weight)
+fuzzy_normalize (gint32 in, double weight)
{
double ms = weight, ams = fabs (ms), ain = fabs (in);
return (double)in;
}
-static const char *
+static const gchar *
fuzzy_to_string (fuzzy_hash_t *h)
{
- static char strbuf [FUZZY_HASHLEN * 2 + 1];
- int i;
+ static gchar strbuf [FUZZY_HASHLEN * 2 + 1];
+ gint i;
guint8 byte;
for (i = 0; i < FUZZY_HASHLEN; i ++) {
return strbuf;
}
-int
+gint
fuzzy_check_module_init (struct config_file *cfg, struct module_ctx **ctx)
{
fuzzy_module_ctx = g_malloc0 (sizeof (struct fuzzy_ctx));
return 0;
}
-int
+gint
fuzzy_check_module_config (struct config_file *cfg)
{
- char *value;
- int res = TRUE;
+ gchar *value;
+ gint res = TRUE;
if ((value = get_module_opt (cfg, "fuzzy_check", "symbol")) != NULL) {
fuzzy_module_ctx->symbol = memory_pool_strdup (fuzzy_module_ctx->fuzzy_pool, value);
return res;
}
-int
+gint
fuzzy_check_module_reconfig (struct config_file *cfg)
{
memory_pool_delete (fuzzy_module_ctx->fuzzy_pool);
/* Call this whenever we got data from fuzzy storage */
static void
-fuzzy_io_callback (int fd, short what, void *arg)
+fuzzy_io_callback (gint fd, short what, void *arg)
{
struct fuzzy_client_session *session = arg;
struct fuzzy_cmd cmd;
struct fuzzy_mapping *map;
- char buf[62], *err_str, *symbol;
- int value = 0, flag = 0, r;
+ gchar buf[62], *err_str, *symbol;
+ gint value = 0, flag = 0, r;
double nval;
if (what == EV_WRITE) {
}
static void
-fuzzy_learn_callback (int fd, short what, void *arg)
+fuzzy_learn_callback (gint fd, short what, void *arg)
{
struct fuzzy_learn_session *session = arg;
struct fuzzy_cmd cmd;
- char buf[64];
- int r;
+ gchar buf[64];
+ gint r;
if (what == EV_WRITE) {
/* Send command to storage */
{
struct fuzzy_client_session *session;
struct storage_server *selected;
- int sock;
+ gint sock;
/* Get upstream */
#ifdef HAVE_CLOCK_GETTIME
struct mime_text_part *part;
struct mime_part *mime_part;
struct rspamd_image *image;
- char *checksum;
+ gchar *checksum;
GList *cur;
fuzzy_hash_t *fake_fuzzy;
/* Check whitelist */
if (fuzzy_module_ctx->whitelist && task->from_addr.s_addr != 0) {
- if (radix32tree_find (fuzzy_module_ctx->whitelist, ntohl ((uint32_t) task->from_addr.s_addr)) != RADIX_NO_VALUE) {
+ if (radix32tree_find (fuzzy_module_ctx->whitelist, ntohl ((guint32) task->from_addr.s_addr)) != RADIX_NO_VALUE) {
msg_info ("<%s>, address %s is whitelisted, skip fuzzy check",
task->message_id, inet_ntoa (task->from_addr));
return;
G_INLINE_FUNC gboolean
register_fuzzy_controller_call (struct controller_session *session, struct worker_task *task, fuzzy_hash_t *h,
- int cmd, int value, int flag, int *saved)
+ gint cmd, gint value, gint flag, gint *saved)
{
struct fuzzy_learn_session *s;
struct storage_server *selected;
- int sock, r;
- char out_buf[BUFSIZ];
+ gint sock, r;
+ gchar out_buf[BUFSIZ];
/* Get upstream */
#ifdef HAVE_CLOCK_GETTIME
struct mime_part *mime_part;
struct rspamd_image *image;
GList *cur;
- int r, cmd = 0, value = 0, flag = 0, *saved, *sargs;
- char out_buf[BUFSIZ], *checksum;
+ gint r, cmd = 0, value = 0, flag = 0, *saved, *sargs;
+ gchar out_buf[BUFSIZ], *checksum;
fuzzy_hash_t fake_fuzzy;
/* Extract arguments */
task->msg->len = in->len;
- saved = memory_pool_alloc0 (session->session_pool, sizeof (int));
+ saved = memory_pool_alloc0 (session->session_pool, sizeof (gint));
r = process_message (task);
if (r == -1) {
msg_warn ("processing of message failed");
}
static void
-fuzzy_controller_handler (char **args, struct controller_session *session, int cmd)
+fuzzy_controller_handler (gchar **args, struct controller_session *session, gint cmd)
{
- char *arg, out_buf[BUFSIZ], *err_str;
- uint32_t size;
- int r, value = 1, flag = 0, *sargs;
+ gchar *arg, out_buf[BUFSIZ], *err_str;
+ guint32 size;
+ gint r, value = 1, flag = 0, *sargs;
/* Process size */
arg = args[0];
rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
session->other_handler = fuzzy_process_handler;
/* Prepare args */
- sargs = memory_pool_alloc (session->session_pool, sizeof (int) * 3);
+ sargs = memory_pool_alloc (session->session_pool, sizeof (gint) * 3);
sargs[0] = cmd;
sargs[1] = value;
sargs[2] = flag;
}
static void
-fuzzy_add_handler (char **args, struct controller_session *session)
+fuzzy_add_handler (gchar **args, struct controller_session *session)
{
fuzzy_controller_handler (args, session, FUZZY_WRITE);
}
static void
-fuzzy_delete_handler (char **args, struct controller_session *session)
+fuzzy_delete_handler (gchar **args, struct controller_session *session)
{
fuzzy_controller_handler (args, session, FUZZY_DEL);
}
-static int
+static gint
fuzzy_mime_filter (struct worker_task *task)
{
/* XXX: remove this */
#define DEFAULT_STATFILE_PREFIX "./"
struct regexp_module_item {
- struct expression *expr;
- char *symbol;
- long int avg_time;
+ struct expression *expr;
+ gchar *symbol;
+ guint32 avg_time;
gpointer lua_function;
};
struct autolearn_data {
- char *statfile_name;
- char *symbol;
+ gchar *statfile_name;
+ gchar *symbol;
float weight;
};
struct regexp_ctx {
- int (*filter) (struct worker_task * task);
+ gint (*filter) (struct worker_task * task);
GHashTable *autolearn_symbols;
- char *statfile_prefix;
+ gchar *statfile_prefix;
memory_pool_t *regexp_pool;
memory_pool_t *dynamic_pool;
};
struct regexp_json_buf {
- u_char *buf;
- u_char *pos;
+ guint8 *buf;
+ guint8 *pos;
size_t buflen;
struct config_file *cfg;
};
static struct regexp_ctx *regexp_module_ctx = NULL;
-static int regexp_common_filter (struct worker_task *task);
+static gint regexp_common_filter (struct worker_task *task);
static gboolean rspamd_regexp_match_number (struct worker_task *task, GList * args, void *unused);
static gboolean rspamd_raw_header_exists (struct worker_task *task, GList * args, void *unused);
static gboolean rspamd_check_smtp_data (struct worker_task *task, GList * args, void *unused);
static void
regexp_dynamic_insert_result (struct worker_task *task, void *user_data)
{
- char *symbol = user_data;
+ gchar *symbol = user_data;
insert_result (task, symbol, 1, NULL);
}
static gboolean
-parse_regexp_ipmask (const char *begin, struct dynamic_map_item *addr)
+parse_regexp_ipmask (const gchar *begin, struct dynamic_map_item *addr)
{
- const char *pos;
- char ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
- int state = 0, dots = 0;
+ 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));
/* Process regexp expression */
static gboolean
-read_regexp_expression (memory_pool_t * pool, struct regexp_module_item *chain, char *symbol, char *line, gboolean raw_mode)
+read_regexp_expression (memory_pool_t * pool, struct regexp_module_item *chain, gchar *symbol, gchar *line, gboolean raw_mode)
{
struct expression *e, *cur;
/* Callbacks for reading json dynamic rules */
-u_char *
-json_regexp_read_cb (memory_pool_t * pool, u_char * chunk, size_t len, struct map_cb_data *data)
+guint8 *
+json_regexp_read_cb (memory_pool_t * pool, guint8 * chunk, size_t len, struct map_cb_data *data)
{
struct regexp_json_buf *jb;
size_t free, off;
json_regexp_fin_cb (memory_pool_t * pool, struct map_cb_data *data)
{
struct regexp_json_buf *jb;
- int nelts, i, j;
+ gint nelts, i, j;
json_t *js, *cur_elt, *cur_nm, *it_val;
json_error_t je;
- char *cur_rule, *cur_symbol;
+ gchar *cur_rule, *cur_symbol;
double score;
gboolean enabled;
struct regexp_module_item *cur_item;
}
/* Init function */
-int
+gint
regexp_module_init (struct config_file *cfg, struct module_ctx **ctx)
{
regexp_module_ctx = g_malloc (sizeof (struct regexp_ctx));
* SYMBOL:statfile:weight
*/
void
-parse_autolearn_param (const char *param, const char *value, struct config_file *cfg)
+parse_autolearn_param (const gchar *param, const gchar *value, struct config_file *cfg)
{
struct autolearn_data *d;
- char *p;
+ gchar *p;
p = memory_pool_strdup (regexp_module_ctx->regexp_pool, value);
d = memory_pool_alloc (regexp_module_ctx->regexp_pool, sizeof (struct autolearn_data));
}
}
-int
+gint
regexp_module_config (struct config_file *cfg)
{
GList *cur_opt = NULL;
struct module_opt *cur;
struct regexp_module_item *cur_item;
- char *value;
- int res = TRUE;
+ gchar *value;
+ gint res = TRUE;
struct regexp_json_buf *jb, **pjb;
if ((value = get_module_opt (cfg, "regexp", "statfile_prefix")) != NULL) {
return res;
}
-int
+gint
regexp_module_reconfig (struct config_file *cfg)
{
memory_pool_delete (regexp_module_ctx->regexp_pool);
return regexp_module_config (cfg);
}
-static const char *
-find_raw_header_pos (const char *headers, const char *headerv)
+static const gchar *
+find_raw_header_pos (const gchar *headers, const gchar *headerv)
{
- const char *p = headers;
+ const gchar *p = headers;
gsize headerlen = strlen (headerv);
if (headers == NULL) {
}
static gsize
-process_regexp (struct rspamd_regexp *re, struct worker_task *task, const char *additional)
+process_regexp (struct rspamd_regexp *re, struct worker_task *task, const gchar *additional)
{
- char *headerv, *c, t;
+ gchar *headerv, *c, t;
struct mime_text_part *part;
GList *cur, *headerlist;
GRegex *regexp;
.re = re,
.found = FALSE
};
- int r;
+ gint r;
if (re == NULL) {
}
cur = headerlist;
while (cur) {
- debug_task ("found header \"%s\" with value \"%s\"", re->header, (const char *)cur->data);
+ debug_task ("found header \"%s\" with value \"%s\"", re->header, (const gchar *)cur->data);
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 char *)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);
}
task_cache_add (task, re, 1);
return 1;
}
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 char *)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);
return 1;
}
else if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for mime part of length %d returned FALSE", re->regexp_text, (int)part->orig->len);
+ msg_info ("process test regexp %s for mime part of length %d returned FALSE", re->regexp_text, (gint)part->orig->len);
}
if (err != NULL) {
msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
if (g_regex_match_full (re->raw_regexp, task->msg->begin, task->msg->len, 0, 0, NULL, &err) == TRUE) {
if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for message of length %d returned TRUE", re->regexp_text, (int)task->msg->len);
+ msg_info ("process test regexp %s for message of length %d returned TRUE", re->regexp_text, (gint)task->msg->len);
}
task_cache_add (task, re, 1);
return 1;
}
else if (G_UNLIKELY (re->is_test)) {
- msg_info ("process test regexp %s for message of length %d returned FALSE", re->regexp_text, (int)task->msg->len);
+ msg_info ("process test regexp %s for message of length %d returned FALSE", re->regexp_text, (gint)task->msg->len);
}
if (err != NULL) {
msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
task_cache_add (task, re, 0);
return 0;
}
- if ((headerv = (char *)find_raw_header_pos (task->raw_headers, re->header)) == NULL) {
+ if ((headerv = (gchar *)find_raw_header_pos (task->raw_headers, re->header)) == NULL) {
/* No header was found */
task_cache_add (task, re, 0);
return 0;
{
struct expression *it = (*e)->next;
gboolean ret = FALSE, is_nearest = TRUE;
- int skip_level = 0;
+ gint skip_level = 0;
/* Skip nearest logical operators from optimization */
if (!it || (it->type == EXPR_OPERATION && it->content.operation != '!')) {
}
static gboolean
-process_regexp_expression (struct expression *expr, char *symbol, struct worker_task *task, const char *additional)
+process_regexp_expression (struct expression *expr, gchar *symbol, struct worker_task *task, const gchar *additional)
{
GQueue *stack;
gsize cur, op1, op2;
}
}
-static int
+static gint
regexp_common_filter (struct worker_task *task)
{
/* XXX: remove this shit too */
static gboolean
rspamd_regexp_match_number (struct worker_task *task, GList * args, void *unused)
{
- int param_count, res = 0;
+ gint param_count, res = 0;
struct expression_argument *arg;
GList *cur;
msg_warn ("invalid argument to function is passed");
return FALSE;
}
- if (find_raw_header_pos (task->raw_headers, (char *)arg->data) == NULL) {
+ if (find_raw_header_pos (task->raw_headers, (gchar *)arg->data) == NULL) {
return FALSE;
}
}
static gboolean
-match_smtp_data (struct worker_task *task, const char *re_text, const char *what)
+match_smtp_data (struct worker_task *task, const gchar *re_text, const gchar *what)
{
struct rspamd_regexp *re;
- int r;
+ 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, (char *)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;
}
- re_cache_add ((char *)re_text, re, task->cfg->cfg_pool);
+ re_cache_add ((gchar *)re_text, re, task->cfg->cfg_pool);
}
if ((r = task_cache_check (task, re)) == -1) {
if (g_regex_match (re->regexp, what, 0, NULL) == TRUE) {
{
struct expression_argument *arg;
GList *cur, *rcpt_list = NULL;
- char *type, *what = NULL;
+ gchar *type, *what = NULL;
if (args == NULL) {
msg_warn ("no parameters to function");
#define DEFAULT_SYMBOL_ALLOW "R_SPF_ALLOW"
struct spf_ctx {
- int (*filter) (struct worker_task * task);
- char *symbol_fail;
- char *symbol_softfail;
- char *symbol_allow;
+ gint (*filter) (struct worker_task * task);
+ gchar *symbol_fail;
+ gchar *symbol_softfail;
+ gchar *symbol_allow;
memory_pool_t *spf_pool;
radix_tree_t *whitelist_ip;
static void spf_symbol_callback (struct worker_task *task, void *unused);
-int
+gint
spf_module_init (struct config_file *cfg, struct module_ctx **ctx)
{
spf_module_ctx = g_malloc (sizeof (struct spf_ctx));
}
-int
+gint
spf_module_config (struct config_file *cfg)
{
- char *value;
- int res = TRUE;
+ gchar *value;
+ gint res = TRUE;
spf_module_ctx->whitelist_ip = radix_tree_create ();
return res;
}
-int
+gint
spf_module_reconfig (struct config_file *cfg)
{
memory_pool_delete (spf_module_ctx->spf_pool);
{
GList *cur;
struct spf_addr *addr;
- uint32_t s, m;
+ guint32 s, m;
if (record) {
cur = g_list_first (record->addrs);
static struct surbl_ctx *surbl_module_ctx = NULL;
-static int surbl_filter (struct worker_task *task);
+static gint surbl_filter (struct worker_task *task);
static void surbl_test_url (struct worker_task *task, void *user_data);
static void dns_callback (struct rspamd_dns_reply *reply, gpointer arg);
-static void process_dns_results (struct worker_task *task, struct suffix_item *suffix, char *url, uint32_t addr);
-static int urls_command_handler (struct worker_task *task);
+static void process_dns_results (struct worker_task *task, struct suffix_item *suffix, gchar *url, guint32 addr);
+static gint urls_command_handler (struct worker_task *task);
#define NO_REGEXP (gpointer)-1
exception_insert (gpointer st, gconstpointer key, gpointer value)
{
GHashTable **t = st;
- int level = 0;
- const char *p = key;
+ gint level = 0;
+ const gchar *p = key;
f_str_t *val;
p ++;
}
if (level >= MAX_LEVELS) {
- msg_err ("invalid domain in exceptions list: %s, levels: %d", (char *)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 = (char *)key;
+ 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);
fin_exceptions_list (memory_pool_t * pool, struct map_cb_data *data)
{
GHashTable **t;
- int i;
+ gint i;
if (data->prev_data) {
t = data->prev_data;
redirector_insert (gpointer st, gconstpointer key, gpointer value)
{
GHashTable *t = st;
- const char *p = key, *begin = key;
+ const gchar *p = key, *begin = key;
gchar *new;
gsize len;
GRegex *re = NO_REGEXP;
}
}
-int
+gint
surbl_module_init (struct config_file *cfg, struct module_ctx **ctx)
{
surbl_module_ctx = g_malloc (sizeof (struct surbl_ctx));
return 0;
}
-int
+gint
surbl_module_config (struct config_file *cfg)
{
GList *cur_opt;
struct suffix_item *new_suffix;
struct surbl_bit_item *new_bit;
- char *value, *str, **strvec;
+ gchar *value, *str, **strvec;
guint32 bit;
gint i, idx;
new_bit = memory_pool_alloc (surbl_module_ctx->surbl_pool, sizeof (struct surbl_bit_item));
new_bit->bit = bit;
new_bit->symbol = memory_pool_strdup (surbl_module_ctx->surbl_pool, cur->value);
- msg_debug ("add new bit suffix: %d with symbol: %s", (int)new_bit->bit, new_bit->symbol);
+ msg_debug ("add new bit suffix: %d with symbol: %s", (gint)new_bit->bit, new_bit->symbol);
surbl_module_ctx->bits = g_list_prepend (surbl_module_ctx->bits, new_bit);
}
}
return TRUE;
}
-int
+gint
surbl_module_reconfig (struct config_file *cfg)
{
/* Delete pool and objects */
-static char *
+static gchar *
format_surbl_request (memory_pool_t * pool, f_str_t * hostname, struct suffix_item *suffix,
gboolean append_suffix, GError ** err, gboolean forced)
{
GHashTable *t;
- char *result = NULL, *dots[MAX_LEVELS], num_buf[sizeof("18446744073709551616")], *p;
- int len, slen, r, i, dots_num = 0, level = MAX_LEVELS;
+ 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;
/* This is ip address */
result = memory_pool_alloc (pool, len);
r = rspamd_snprintf (result, len, "%*s.%*s.%*s.%*s",
- (int)(hostname->len - (dots[2] - hostname->begin + 1)),
+ (gint)(hostname->len - (dots[2] - hostname->begin + 1)),
dots[2] + 1,
- (int)(dots[2] - dots[1] - 1),
+ (gint)(dots[2] - dots[1] - 1),
dots[1] + 1,
- (int)(dots[1] - dots[0] - 1),
+ (gint)(dots[1] - dots[0] - 1),
dots[0] + 1,
- (int)(dots[0] - hostname->begin),
+ (gint)(dots[0] - hostname->begin),
hostname->begin);
}
else if (is_numeric && dots_num == 0) {
ip_num &= 0xFFFFFFFF;
/* Get octets */
r = rspamd_snprintf (result, len, "%ud.%ud.%ud.%ud",
- (uint32_t) ip_num & 0x000000FF, (uint32_t) (ip_num & 0x0000FF00) >> 8, (uint32_t) (ip_num & 0x00FF0000) >> 16, (uint32_t) (ip_num & 0xFF000000) >> 24);
+ (guint32) ip_num & 0x000000FF, (guint32) (ip_num & 0x0000FF00) >> 8, (guint32) (ip_num & 0x00FF0000) >> 16, (guint32) (ip_num & 0xFF000000) >> 24);
}
else {
/* Not a numeric url */
}
if (level != MAX_LEVELS) {
if (level == 0) {
- r = rspamd_snprintf (result, len, "%*s", (int)hostname->len, hostname->begin);
+ r = rspamd_snprintf (result, len, "%*s", (gint)hostname->len, hostname->begin);
}
else {
r = rspamd_snprintf (result, len, "%*s",
- (int)(hostname->len - (dots[level - 1] - hostname->begin + 1)),
+ (gint)(hostname->len - (dots[level - 1] - hostname->begin + 1)),
dots[level - 1] + 1);
}
}
else if (dots_num >= 2) {
r = rspamd_snprintf (result, len, "%*s",
- (int)(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", (int)hostname->len, hostname->begin);
+ r = rspamd_snprintf (result, len, "%*s", (gint)hostname->len, hostname->begin);
}
}
r += rspamd_snprintf (result + r, len - r, ".%s", suffix->suffix);
}
- msg_debug ("request: %s, dots: %d, level: %d, orig: %*s", result, dots_num, level, (int)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;
}
make_surbl_requests (struct uri *url, struct worker_task *task, GTree * tree,
struct suffix_item *suffix, gboolean forced)
{
- char *surbl_req;
+ gchar *surbl_req;
f_str_t f;
GError *err = NULL;
struct dns_param *param;
}
static void
-process_dns_results (struct worker_task *task, struct suffix_item *suffix, char *url, uint32_t addr)
+process_dns_results (struct worker_task *task, struct suffix_item *suffix, gchar *url, guint32 addr)
{
- char *c, *symbol;
+ gchar *c, *symbol;
GList *cur;
struct surbl_bit_item *bit;
- int len, found = 0;
+ gint len, found = 0;
if ((c = strchr (suffix->symbol, '%')) != NULL && *(c + 1) == 'b') {
cur = g_list_first (surbl_module_ctx->bits);
while (cur) {
bit = (struct surbl_bit_item *)cur->data;
- debug_task ("got result(%d) AND bit(%d): %d", (int)addr, (int)ntohl (bit->bit), (int)bit->bit & (int)ntohl (addr));
- if (((int)bit->bit & (int)ntohl (addr)) != 0) {
+ 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) {
len = strlen (suffix->symbol) - 2 + strlen (bit->symbol) + 1;
*c = '\0';
symbol = memory_pool_alloc (task->task_pool, len);
if (reply->code == DNS_RC_NOERROR && reply->elements) {
msg_info ("<%s> domain [%s] is in surbl %s", param->task->message_id, param->host_resolve, param->suffix->suffix);
elt = reply->elements->data;
- process_dns_results (param->task, param->suffix, param->host_resolve, (uint32_t)elt->a.addr[0].s_addr);
+ process_dns_results (param->task, param->suffix, param->host_resolve, (guint32)elt->a.addr[0].s_addr);
}
else {
debug_task ("<%s> domain [%s] is not in surbl %s", param->task->message_id, param->host_resolve, param->suffix->suffix);
memcached_callback (memcached_ctx_t * ctx, memc_error_t error, void *data)
{
struct memcached_param *param = (struct memcached_param *)data;
- int *url_count;
+ gint *url_count;
switch (ctx->op) {
case CMD_CONNECT:
}
}
else {
- url_count = (int *)param->ctx->param->buf;
+ url_count = (gint *)param->ctx->param->buf;
/* Do not check DNS for urls that have count more than max_urls */
if (*url_count > surbl_module_ctx->max_urls) {
msg_info ("url '%s' has count %d, max: %d", struri (param->url), *url_count, surbl_module_ctx->max_urls);
struct memcached_server *selected;
memcached_param_t *cur_param;
gchar *sum_str;
- int *url_count;
+ gint *url_count;
param = memory_pool_alloc (task->task_pool, sizeof (struct memcached_param));
cur_param = memory_pool_alloc0 (task->task_pool, sizeof (memcached_param_t));
- url_count = memory_pool_alloc (task->task_pool, sizeof (int));
+ url_count = memory_pool_alloc (task->task_pool, sizeof (gint));
param->url = url;
param->task = task;
param->ctx = memory_pool_alloc0 (task->task_pool, sizeof (memcached_ctx_t));
cur_param->buf = (u_char *) url_count;
- cur_param->bufsize = sizeof (int);
+ cur_param->bufsize = sizeof (gint);
sum_str = g_compute_checksum_for_string (G_CHECKSUM_MD5, struri (url), -1);
g_strlcpy (cur_param->key, sum_str, sizeof (cur_param->key));
}
static void
-redirector_callback (int fd, short what, void *arg)
+redirector_callback (gint fd, short what, void *arg)
{
struct redirector_param *param = (struct redirector_param *)arg;
struct worker_task *task = param->task;
- char url_buf[1024];
- int r;
+ gchar url_buf[1024];
+ gint r;
struct timeval *timeout;
- char *p, *c;
+ gchar *p, *c;
switch (param->state) {
case STATE_CONNECT:
static void
register_redirector_call (struct uri *url, struct worker_task *task, GTree * url_tree, struct suffix_item *suffix)
{
- int s = -1;
+ gint s = -1;
struct redirector_param *param;
struct timeval *timeout;
struct redirector_upstream *selected;
struct worker_task *task = param->task;
struct uri *url = value;
f_str_t f;
- char *red_domain;
+ gchar *red_domain;
GRegex *re;
guint idx;
memory_pool_add_destructor (task->task_pool, (pool_destruct_func) g_tree_destroy, url_tree);
}
-static int
+static gint
surbl_filter (struct worker_task *task)
{
/* XXX: remove this shit */
urls_command_handler (struct worker_task *task)
{
GList *cur;
- char *outbuf, *urlstr;
- int r, num = 0, buflen;
+ gchar *outbuf, *urlstr;
+ gint r, num = 0, buflen;
struct uri *url;
GError *err = NULL;
GTree *url_tree;
buflen += sizeof (RSPAMD_REPLY_BANNER " 0 OK" CRLF CRLF "Urls: ");
- outbuf = memory_pool_alloc (task->task_pool, buflen * sizeof (char));
+ outbuf = memory_pool_alloc (task->task_pool, buflen * sizeof (gchar));
r = rspamd_snprintf (outbuf, buflen, "%s 0 %s" CRLF, (task->proto == SPAMC_PROTO) ? SPAMD_REPLY_BANNER : RSPAMD_REPLY_BANNER, "OK");
f.len = url->hostlen;
if ((urlstr = format_surbl_request (task->task_pool, &f, NULL, FALSE, &err, FALSE)) != NULL) {
if (g_list_next (cur) != NULL) {
- r += rspamd_snprintf (outbuf + r, buflen - r - 2, "%s <\"%s\">, ", (char *)urlstr, struri (url));
+ r += rspamd_snprintf (outbuf + r, buflen - r - 2, "%s <\"%s\">, ", (gchar *)urlstr, struri (url));
}
else {
- r += rspamd_snprintf (outbuf + r, buflen - r - 2, "%s <\"%s\">", (char *)urlstr, struri (url));
+ r += rspamd_snprintf (outbuf + r, buflen - r - 2, "%s <\"%s\">", (gchar *)urlstr, struri (url));
}
}
}
};
struct surbl_ctx {
- int (*filter)(struct worker_task *task);
- uint16_t weight;
- unsigned int connect_timeout;
- unsigned int read_timeout;
- unsigned int max_urls;
- unsigned int url_expire;
+ gint (*filter)(struct worker_task *task);
+ guint16 weight;
+ guint connect_timeout;
+ guint read_timeout;
+ guint max_urls;
+ guint url_expire;
GList *suffixes;
GList *bits;
- char *metric;
- const char *tld2_file;
- const char *whitelist_file;
+ gchar *metric;
+ const gchar *tld2_file;
+ const gchar *whitelist_file;
GHashTable **exceptions;
GHashTable *whitelist;
GHashTable *redirector_hosts;
rspamd_trie_t *redirector_trie;
GPtrArray *redirector_ptrs;
- unsigned use_redirector;
+ guint use_redirector;
struct redirector_upstream *redirectors;
guint32 redirectors_number;
memory_pool_t *surbl_pool;
};
struct suffix_item {
- const char *suffix;
- const char *symbol;
+ const gchar *suffix;
+ const gchar *symbol;
};
struct dns_param {
struct uri *url;
struct worker_task *task;
- char *host_resolve;
+ gchar *host_resolve;
struct suffix_item *suffix;
};
STATE_READ,
} state;
struct event ev;
- int sock;
+ gint sock;
GTree *tree;
struct suffix_item *suffix;
};
};
struct surbl_bit_item {
- uint32_t bit;
- const char *symbol;
+ guint32 bit;
+ const gchar *symbol;
};
#endif
/* For default metric, dirty hack, but much faster than hash lookup */
static double default_score, default_required_score;
-G_INLINE_FUNC const char *
+G_INLINE_FUNC const gchar *
rspamc_proto_str (guint ver)
{
if (ver >= 12) {
}
}
-static char *
-separate_command (f_str_t * in, char c)
+static gchar *
+separate_command (f_str_t * in, gchar c)
{
- int r = 0;
- char *p = in->begin, *b;
+ gint r = 0;
+ gchar *p = in->begin, *b;
b = p;
while (r < in->len) {
return NULL;
}
-static int
+static gint
parse_command (struct worker_task *task, f_str_t * line)
{
- char *token;
+ gchar *token;
struct custom_command *cmd;
GList *cur;
return 0;
}
-static int
+static gint
parse_header (struct worker_task *task, f_str_t * line)
{
- char *headern, *err, *tmp;
+ gchar *headern, *err, *tmp;
/* Check end of headers */
if (line->len == 0) {
if (task->content_length == 0) {
tmp = memory_pool_fstrdup (task->task_pool, line);
task->content_length = strtoul (tmp, &err, 10);
- debug_task ("read Content-Length header, value: %ul", (unsigned long int)task->content_length);
+ debug_task ("read Content-Length header, value: %ul", (guint32)task->content_length);
}
}
else {
else if (g_ascii_strncasecmp (headern, NRCPT_HEADER, sizeof (NRCPT_HEADER) - 1) == 0) {
tmp = memory_pool_fstrdup (task->task_pool, line);
task->nrcpt = strtoul (tmp, &err, 10);
- debug_task ("read rcpt header, value: %d", (int)task->nrcpt);
+ debug_task ("read rcpt header, value: %d", (gint)task->nrcpt);
}
else {
msg_info ("wrong header: %s", headern);
return 0;
}
-int
+gint
read_rspamd_input_line (struct worker_task *task, f_str_t * line)
{
switch (task->state) {
struct metric_callback_data {
struct worker_task *task;
- char *log_buf;
- int log_offset;
- int log_size;
+ gchar *log_buf;
+ gint log_offset;
+ gint log_size;
gboolean alive;
};
static void
-write_hashes_to_log (struct worker_task *task, char *logbuf, int offset, int size)
+write_hashes_to_log (struct worker_task *task, gchar *logbuf, gint offset, gint size)
{
GList *cur;
struct mime_text_part *text_part;
static gboolean
show_url_header (struct worker_task *task)
{
- int r = 0;
- char outbuf[OUTBUFSIZ], c;
+ gint r = 0;
+ gchar outbuf[OUTBUFSIZ], c;
struct uri *url;
GList *cur;
f_str_t host;
{
struct metric_callback_data *cd = (struct metric_callback_data *)user_data;
struct worker_task *task = cd->task;
- int r = 0;
- char outbuf[OUTBUFSIZ];
+ gint r = 0;
+ gchar outbuf[OUTBUFSIZ];
struct symbol *s = (struct symbol *)value;
GList *cur;
if (s->options) {
if (task->proto_ver >= 12) {
- r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s(%.2f); ", (char *)key, s->score);
+ r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s(%.2f); ", (gchar *)key, s->score);
}
else {
- r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s; ", (char *)key);
+ r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s; ", (gchar *)key);
}
cur = s->options;
while (cur) {
if (g_list_next (cur)) {
- r += rspamd_snprintf (outbuf + r, OUTBUFSIZ - r, "%s,", (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, OUTBUFSIZ - r, "%s,", (gchar *)cur->data);
}
else {
- r += rspamd_snprintf (outbuf + r, OUTBUFSIZ - r, "%s" CRLF, (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, OUTBUFSIZ - r, "%s" CRLF, (gchar *)cur->data);
}
cur = g_list_next (cur);
}
}
else {
if (task->proto_ver >= 12) {
- r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s(%.2f)" CRLF, (char *)key, s->score);
+ r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s(%.2f)" CRLF, (gchar *)key, s->score);
}
else {
- r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s" CRLF, (char *)key);
+ r = rspamd_snprintf (outbuf, OUTBUFSIZ, "Symbol: %s" CRLF, (gchar *)key);
}
}
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "%s,", (char *)key);
+ cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "%s,", (gchar *)key);
if (! rspamd_dispatcher_write (task->dispatcher, outbuf, r, FALSE, FALSE)) {
cd->alive = FALSE;
static gboolean
show_metric_symbols (struct metric_result *metric_res, struct metric_callback_data *cd)
{
- int r = 0;
+ gint r = 0;
GList *symbols, *cur;
- char outbuf[OUTBUFSIZ];
+ gchar outbuf[OUTBUFSIZ];
if (cd->task->proto == SPAMC_PROTO) {
symbols = g_hash_table_get_keys (metric_res->symbols);
cur = symbols;
while (cur) {
if (g_list_next (cur) != NULL) {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s,", (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s,", (gchar *)cur->data);
}
else {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s" CRLF, (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "%s" CRLF, (gchar *)cur->data);
}
cur = g_list_next (cur);
}
return TRUE;
}
-const char *
+const gchar *
str_action_metric (enum rspamd_metric_action action)
{
switch (action) {
{
struct metric_callback_data *cd = (struct metric_callback_data *)user_data;
struct worker_task *task = cd->task;
- int r = 0;
- char outbuf[OUTBUFSIZ];
+ gint r = 0;
+ gchar outbuf[OUTBUFSIZ];
struct metric_result *metric_res = (struct metric_result *)metric_value;
struct metric *m;
- int is_spam = 0;
+ gint is_spam = 0;
double ms = 0, rs = 0;
enum rspamd_metric_action action;
if (task->proto_ver >= 11) {
if (!task->is_skipped) {
r = rspamd_snprintf (outbuf, sizeof (outbuf), "Metric: %s; %s; %.2f / %.2f / %.2f" CRLF,
- (char *)metric_name, (is_spam) ? "True" : "False", metric_res->score, ms, rs);
+ (gchar *)metric_name, (is_spam) ? "True" : "False", metric_res->score, ms, rs);
}
else {
r = rspamd_snprintf (outbuf, sizeof (outbuf), "Metric: %s; Skip; %.2f / %.2f / %.2f" CRLF,
- (char *)metric_name, metric_res->score, ms, rs);
+ (gchar *)metric_name, metric_res->score, ms, rs);
}
}
else {
r = rspamd_snprintf (outbuf, sizeof (outbuf), "Metric: %s; %s; %.2f / %.2f" CRLF,
- (char *)metric_name, (is_spam) ? "True" : "False", metric_res->score, ms);
+ (gchar *)metric_name, (is_spam) ? "True" : "False", metric_res->score, ms);
}
r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "Action: %s" CRLF, str_action_metric(action));
}
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] [",
- (char *)metric_name, is_spam ? 'T' : 'F', str_action_metric (action), metric_res->score, ms, rs);
+ (gchar *)metric_name, 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 (%s): [%.2f/%.2f/%.2f] [",
- (char *)metric_name, '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 *)metric_name, 'S', metric_res->score, ms, rs);
}
}
}
}
#ifdef HAVE_CLOCK_GETTIME
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "]), len: %l, time: %s,",
- (long int)task->msg->len, calculate_check_time (&task->tv, &task->ts, task->cfg->clock_res));
+ 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));
#else
- cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "]), len: %l, time: %s,",
- (long int)task->msg->len, calculate_check_time (&task->tv, task->cfg->clock_res));
+ 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));
#endif
}
static gboolean
show_messages (struct worker_task *task)
{
- int r = 0;
- char outbuf[OUTBUFSIZ];
+ gint r = 0;
+ gchar outbuf[OUTBUFSIZ];
GList *cur;
cur = task->messages;
while (cur) {
- r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "Message: %s" CRLF, (char *)cur->data);
+ r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "Message: %s" CRLF, (gchar *)cur->data);
cur = g_list_next (cur);
}
static gboolean
write_check_reply (struct worker_task *task)
{
- int r;
- char outbuf[OUTBUFSIZ], logbuf[OUTBUFSIZ];
+ gint r;
+ gchar outbuf[OUTBUFSIZ], logbuf[OUTBUFSIZ];
struct metric_result *metric_res;
struct metric_callback_data cd;
static gboolean
write_process_reply (struct worker_task *task)
{
- int r;
- char *outmsg;
- char outbuf[OUTBUFSIZ], logbuf[OUTBUFSIZ];
+ gint r;
+ gchar *outmsg;
+ gchar outbuf[OUTBUFSIZ], logbuf[OUTBUFSIZ];
struct metric_result *metric_res;
struct metric_callback_data cd;
gboolean
write_reply (struct worker_task *task)
{
- int r;
- char outbuf[OUTBUFSIZ];
+ gint r;
+ gchar outbuf[OUTBUFSIZ];
debug_task ("writing reply to client");
if (task->error_code != 0) {
}
void
-register_protocol_command (const char *name, protocol_reply_func func)
+register_protocol_command (const gchar *name, protocol_reply_func func)
{
struct custom_command *cmd;
};
-typedef int (*protocol_reply_func)(struct worker_task *task);
+typedef gint (*protocol_reply_func)(struct worker_task *task);
struct custom_command {
- const char *name;
+ const gchar *name;
protocol_reply_func func;
};
* @param line line of user's input
* @return 0 if line was successfully parsed and -1 if we have protocol error
*/
-int read_rspamd_input_line (struct worker_task *task, f_str_t *line);
+gint read_rspamd_input_line (struct worker_task *task, f_str_t *line);
/**
* Write reply for specified task command
* @param name symbolic name of custom function
* @param func callback function for writing reply
*/
-void register_protocol_command (const char *name, protocol_reply_func func);
+void register_protocol_command (const gchar *name, protocol_reply_func func);
-const char *str_action_metric (enum rspamd_metric_action action);
+const gchar *str_action_metric (enum rspamd_metric_action action);
gint check_metric_action (double score, double required_score, struct metric *metric);
#endif
};
static uintptr_t
-radix32tree_insert_common (radix_tree_t * tree, uint32_t key, uint32_t 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)
{
- uint32_t bit;
+ guint32 bit;
radix_node_t *node, *next;
bit = 0x80000000;
return 0;
}
-int
-radix32tree_insert (radix_tree_t *tree, uint32_t key, uint32_t mask, uintptr_t value)
+gint
+radix32tree_insert (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
{
- return (int)radix32tree_insert_common (tree, key, mask, value, RADIX_INSERT);
+ return (gint)radix32tree_insert_common (tree, key, mask, value, RADIX_INSERT);
}
uintptr_t
-radix32tree_add (radix_tree_t *tree, uint32_t key, uint32_t mask, uintptr_t value)
+radix32tree_add (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
{
return radix32tree_insert_common (tree, key, mask, value, RADIX_ADD);
}
-int
-radix32tree_replace (radix_tree_t *tree, uint32_t key, uint32_t mask, uintptr_t value)
+gint
+radix32tree_replace (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
{
- return (int)radix32tree_insert_common (tree, key, mask, value, RADIX_REPLACE);
+ return (gint)radix32tree_insert_common (tree, key, mask, value, RADIX_REPLACE);
}
/*
* per recursion step:
- * ptr + ptr + ptr + int = 4 words
+ * ptr + ptr + ptr + gint = 4 words
* result = 1 word
* 5 words total in stack
*/
static gboolean
-radix_recurse_nodes (radix_node_t *node, radix_tree_traverse_func func, void *user_data, int 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)) {
}
-int
-radix32tree_delete (radix_tree_t * tree, uint32_t key, uint32_t mask)
+gint
+radix32tree_delete (radix_tree_t * tree, guint32 key, guint32 mask)
{
- uint32_t bit;
+ guint32 bit;
radix_node_t *node;
radix_node_t *tmp;
uintptr_t
-radix32tree_find (radix_tree_t * tree, uint32_t key)
+radix32tree_find (radix_tree_t * tree, guint32 key)
{
- uint32_t bit;
+ guint32 bit;
uintptr_t value;
radix_node_t *node;
static void *
radix_alloc (radix_tree_t * tree)
{
- char *p;
+ gchar *p;
p = memory_pool_alloc (tree->pool, sizeof (radix_node_t));
radix_node_t *left;
radix_node_t *parent;
uintptr_t value;
- uint32_t key;
+ guint32 key;
};
memory_pool_t *pool;
} radix_tree_t;
-typedef gboolean (*radix_tree_traverse_func)(uint32_t key, uint32_t 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
* 0 if operation was successfull
* -1 if there was some error
*/
-int radix32tree_insert (radix_tree_t *tree, uint32_t key, uint32_t 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, uint32_t key, uint32_t 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
*/
-int radix32tree_replace (radix_tree_t *tree, uint32_t key, uint32_t mask, uintptr_t value);
+gint radix32tree_replace (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
/**
* Delete value from radix tree
* 0 if value was deleted
* -1 if there was some error
*/
-int radix32tree_delete (radix_tree_t *tree, uint32_t key, uint32_t mask);
+gint radix32tree_delete (radix_tree_t *tree, guint32 key, guint32 mask);
/**
* Find value in radix tree
* returns: value if value was found
* RADIX_NO_VALUE if value was not found
*/
-uintptr_t radix32tree_find (radix_tree_t *tree, uint32_t key);
+uintptr_t radix32tree_find (radix_tree_t *tree, guint32 key);
/**
* Traverse via the whole tree calling specified callback
json_fin_cb (memory_pool_t * pool, struct map_cb_data *data)
{
struct json_buf *jb;
- int nelts, i, n, a;
+ gint nelts, i, n, a;
json_t *js, *cur_elt, *cur_nm, *it_val;
json_error_t je;
struct rspamd_settings *cur_settings;
- char *cur_name;
+ gchar *cur_name;
void *json_it;
double *score;
}
gboolean
-read_settings (const char *path, struct config_file *cfg, GHashTable * table)
+read_settings (const gchar *path, struct config_file *cfg, GHashTable * table)
{
struct json_buf *jb = g_malloc (sizeof (struct json_buf)), **pjb;
static gboolean
check_setting (struct worker_task *task, struct rspamd_settings **user_settings, struct rspamd_settings **domain_settings)
{
- char *field = NULL, *domain = NULL;
+ gchar *field = NULL, *domain = NULL;
if (task->deliver_to != NULL) {
/* First try to use deliver-to field */
static gboolean
check_whitelist(struct worker_task *task, struct rspamd_settings *s)
{
- char *src_email = NULL, *src_domain = NULL;
+ gchar *src_email = NULL, *src_domain = NULL;
if (task->from != NULL) {
src_email = task->from;
}
gboolean
-check_factor_settings (struct worker_task * task, const char *symbol, double *factor)
+check_factor_settings (struct worker_task * task, const gchar *symbol, double *factor)
{
struct rspamd_settings *us = NULL, *ds = NULL;
double *fc;
GHashTable *reject_scores; /**< hash table of metric reject scores for this setting */
GHashTable *factors; /**< hash table of new factors for this setting */
GHashTable *whitelist; /**< hash table of whitelist for this setting */
- char *statfile_alias; /**< alias for statfile used */
+ gchar *statfile_alias; /**< alias for statfile used */
gboolean want_spam; /**< if true disable rspamd checks */
};
-gboolean read_settings (const char *path, struct config_file *cfg, GHashTable *table);
+gboolean read_settings (const gchar *path, struct config_file *cfg, GHashTable *table);
void init_settings (struct config_file *cfg);
gboolean check_metric_settings (struct worker_task *task, struct metric *metric, double *score, double *rscore);
-gboolean check_factor_settings (struct worker_task *task, const char *symbol, double *factor);
+gboolean check_factor_settings (struct worker_task *task, const gchar *symbol, double *factor);
gboolean check_want_spam (struct worker_task *task);
#endif
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t *info, void *unused)
#endif
{
struct timeval tv;
* Config reload is designed by sending sigusr to active workers and pending shutdown of them
*/
static void
-sigusr_handler (int fd, short what, void *arg)
+sigusr_handler (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
/* Do not accept new connections, preparing to end worker's process */
read_smtp_command (struct smtp_session *session, f_str_t *line)
{
struct smtp_command *cmd;
- char outbuf[BUFSIZ];
- int r;
+ gchar outbuf[BUFSIZ];
+ gint r;
if (! parse_smtp_command (session, line, &cmd)) {
session->error = SMTP_ERROR_BAD_COMMAND;
process_smtp_data (struct smtp_session *session)
{
struct stat st;
- int r;
+ gint r;
GList *cur, *t;
f_str_t *f;
- char *s;
+ gchar *s;
if (fstat (session->temp_fd, &st) == -1) {
msg_err ("fstat failed: %s", strerror (errno));
{
struct smtp_session *session = arg;
double ms = 0, rs = 0;
- int r;
+ gint r;
struct metric_result *metric_res;
struct metric *m;
- char logbuf[1024];
+ gchar logbuf[1024];
gboolean is_spam = FALSE;
GList *symbols, *cur;
r = rspamd_snprintf (logbuf, sizeof (logbuf), "msg ok, id: <%s>, ", session->task->message_id);
r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "(%s: %s: [%.2f/%.2f/%.2f] [",
- (char *)m->name, is_spam ? "T" : "F", metric_res->score, ms, rs);
+ (gchar *)m->name, is_spam ? "T" : "F", metric_res->score, ms, rs);
symbols = g_hash_table_get_keys (metric_res->symbols);
cur = symbols;
while (cur) {
if (g_list_next (cur) != NULL) {
- r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "%s,", (char *)cur->data);
+ r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "%s,", (gchar *)cur->data);
}
else {
- r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "%s", (char *)cur->data);
+ r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "%s", (gchar *)cur->data);
}
cur = g_list_next (cur);
}
g_list_free (symbols);
#ifdef HAVE_CLOCK_GETTIME
- r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "]), len: %l, time: %s",
- (long int)session->task->msg->len, calculate_check_time (&session->task->tv, &session->task->ts, session->cfg->clock_res));
+ r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "]), len: %z, time: %s",
+ session->task->msg->len, calculate_check_time (&session->task->tv, &session->task->ts, session->cfg->clock_res));
#else
- r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "]), len: %l, time: %s",
- (long int)session->task->msg->len, calculate_check_time (&session->task->tv, session->cfg->clock_res));
+ r += rspamd_snprintf (logbuf + r, sizeof (logbuf) - r, "]), len: %z, time: %s",
+ session->task->msg->len, calculate_check_time (&session->task->tv, session->cfg->clock_res));
#endif
msg_info ("%s", logbuf);
* Return from a delay
*/
static void
-smtp_delay_handler (int fd, short what, void *arg)
+smtp_delay_handler (gint fd, short what, void *arg)
{
struct smtp_session *session = arg;
smtp_dns_cb (struct rspamd_dns_reply *reply, void *arg)
{
struct smtp_session *session = arg;
- int res = 0;
+ gint res = 0;
union rspamd_reply_element *elt;
GList *cur;
* Accept new connection and construct task
*/
static void
-accept_socket (int fd, short what, void *arg)
+accept_socket (gint fd, short what, void *arg)
{
struct rspamd_worker *worker = (struct rspamd_worker *)arg;
union sa_union su;
struct smtp_worker_ctx *ctx;
socklen_t addrlen = sizeof (su.ss);
- int nfd;
+ gint nfd;
if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
}
static void
-parse_smtp_banner (struct smtp_worker_ctx *ctx, const char *line)
+parse_smtp_banner (struct smtp_worker_ctx *ctx, const gchar *line)
{
- int hostmax, banner_len = sizeof ("220 ") - 1;
- char *p, *t, *hostbuf = NULL;
+ gint hostmax, banner_len = sizeof ("220 ") - 1;
+ gchar *p, *t, *hostbuf = NULL;
gboolean has_crlf = FALSE;
- p = (char *)line;
+ p = (gchar *)line;
while (*p) {
if (*p == '%') {
p ++;
ctx->smtp_banner = memory_pool_alloc (ctx->pool, banner_len + 1);
t = ctx->smtp_banner;
- p = (char *)line;
+ p = (gchar *)line;
if (has_crlf) {
t = g_stpcpy (t, "220-");
p ++;
break;
default:
- /* Copy all %<char> to dest */
+ /* Copy all %<gchar> to dest */
*t++ = *(p - 1); *t++ = *p;
break;
}
}
static gboolean
-parse_upstreams_line (struct smtp_worker_ctx *ctx, const char *line)
+parse_upstreams_line (struct smtp_worker_ctx *ctx, const gchar *line)
{
- char **strv, *p, *t, *tt, *err_str;
- uint32_t num, i;
+ gchar **strv, *p, *t, *tt, *err_str;
+ guint32 num, i;
struct smtp_upstream *cur;
- char resolved_path[PATH_MAX];
+ gchar resolved_path[PATH_MAX];
strv = g_strsplit_set (line, ",; ", -1);
num = g_strv_length (strv);
}
static void
-make_capabilities (struct smtp_worker_ctx *ctx, const char *line)
+make_capabilities (struct smtp_worker_ctx *ctx, const gchar *line)
{
- char **strv, *p, *result, *hostbuf;
- uint32_t 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);
config_smtp_worker (struct rspamd_worker *worker)
{
struct smtp_worker_ctx *ctx;
- char *value;
- uint32_t timeout;
+ gchar *value;
+ guint32 timeout;
ctx = g_malloc0 (sizeof (struct smtp_worker_ctx));
ctx->pool = memory_pool_new (memory_pool_get_size ());
struct smtp_upstream {
struct upstream up;
- const char *name;
+ const gchar *name;
struct in_addr addr;
- uint16_t port;
+ guint16 port;
gboolean is_unix;
};
size_t upstream_num;
memory_pool_t *pool;
- char *smtp_banner;
- uint32_t smtp_delay;
- uint32_t delay_jitter;
+ gchar *smtp_banner;
+ guint32 smtp_delay;
+ guint32 delay_jitter;
struct timeval smtp_timeout;
gboolean use_xclient;
gboolean helo_required;
- char *smtp_capabilities;
- char *reject_message;
+ gchar *smtp_capabilities;
+ gchar *reject_message;
size_t max_size;
guint max_errors;
- char *metric;
+ gchar *metric;
GList *smtp_filters[SMTP_STAGE_MAX];
struct rspamd_dns_resolver *resolver;
};
struct rspamd_worker *worker;
struct worker_task *task;
struct in_addr client_addr;
- char *hostname;
- char *error;
- char *temp_name;
- int sock;
- int upstream_sock;
- int temp_fd;
+ gchar *hostname;
+ gchar *error;
+ gchar *temp_name;
+ gint sock;
+ gint upstream_sock;
+ gint temp_fd;
size_t temp_size;
time_t session_time;
#include "smtp.h"
#include "smtp_proto.h"
-char *
-make_smtp_error (struct smtp_session *session, int error_code, const char *format, ...)
+gchar *
+make_smtp_error (struct smtp_session *session, gint error_code, const gchar *format, ...)
{
va_list vp;
- char *result = NULL, *p;
+ gchar *result = NULL, *p;
size_t len;
va_start (vp, format);
SMTP_PARSE_DONE
} state;
gchar *p, *c, ch, cmd_buf[4];
- int i;
+ gint i;
f_str_t *arg = NULL;
struct smtp_command *pcmd;
}
}
else if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
- msg_info ("invalid letter code in SMTP command: %d", (int)ch);
+ msg_info ("invalid letter code in SMTP command: %d", (gint)ch);
return FALSE;
}
break;
static gboolean
check_smtp_path (f_str_t *path)
{
- int i;
- char *p;
+ gint i;
+ gchar *p;
p = path->begin;
if (*p != '<' || path->len < 2) {
}
/* Return -1 if there are some error, 1 if all is ok and 0 in case of incomplete reply */
-static int
-check_smtp_ustream_reply (f_str_t *in, char success_code)
+static gint
+check_smtp_ustream_reply (f_str_t *in, gchar success_code)
{
- char *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, char *buf, size_t buflen)
+smtp_upstream_write_list (GList *args, gchar *buf, size_t buflen)
{
GList *cur = args;
size_t r = 0;
smtp_upstream_read_socket (f_str_t * in, void *arg)
{
struct smtp_session *session = arg;
- char outbuf[BUFSIZ];
- int r;
+ gchar outbuf[BUFSIZ];
+ gint r;
switch (session->upstream_state) {
case SMTP_STATE_GREETING:
GList *args;
};
-char * make_smtp_error (struct smtp_session *session, int error_code, const char *format, ...);
+gchar * make_smtp_error (struct smtp_session *session, gint error_code, const gchar *format, ...);
gboolean parse_smtp_command (struct smtp_session *session, f_str_t *line, struct smtp_command **cmd);
gboolean parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd);
gboolean parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd);
gboolean smtp_upstream_write_socket (void *arg);
void smtp_upstream_err_socket (GError *err, void *arg);
void smtp_upstream_finalize_connection (gpointer data);
-size_t smtp_upstream_write_list (GList *args, char *buf, size_t buflen);
+size_t smtp_upstream_write_list (GList *args, gchar *buf, size_t buflen);
#endif
} while (0) \
static gboolean parse_spf_record (struct worker_task *task, struct spf_record *rec);
-static void start_spf_parse (struct spf_record *rec, char *begin);
+static void start_spf_parse (struct spf_record *rec, gchar *begin);
/* Determine spf mech */
static spf_mech_t
-check_spf_mech (const char *elt, gboolean *need_shift)
+check_spf_mech (const gchar *elt, gboolean *need_shift)
{
g_assert (elt != NULL);
}
static gboolean
-parse_spf_ipmask (const char *begin, struct spf_addr *addr)
+parse_spf_ipmask (const gchar *begin, struct spf_addr *addr)
{
- const char *pos;
- char ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
- int state = 0, dots = 0;
+ const gchar *pos;
+ gchar ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
+ gint state = 0, dots = 0;
struct in_addr in;
bzero (ip_buf, sizeof (ip_buf));
}
-static char *
-parse_spf_hostmask (struct worker_task *task, const char *begin, struct spf_addr *addr, struct spf_record *rec)
+static gchar *
+parse_spf_hostmask (struct worker_task *task, const gchar *begin, struct spf_addr *addr, struct spf_record *rec)
{
- char *host = NULL, *p, mask_buf[3];
- int hostlen;
+ gchar *host = NULL, *p, mask_buf[3];
+ gint hostlen;
bzero (mask_buf, sizeof (mask_buf));
if (*begin == '\0' || *begin == '/') {
spf_record_dns_callback (struct rspamd_dns_reply *reply, gpointer arg)
{
struct spf_dns_cb *cb = arg;
- char *begin;
+ gchar *begin;
union rspamd_reply_element *elt_data;
GList *tmp = NULL, *tmp1, *elt, *last;
struct worker_task *task;
}
static gboolean
-parse_spf_a (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_a (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- char *host;
+ gchar *host;
CHECK_REC (rec);
}
static gboolean
-parse_spf_ptr (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_ptr (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
CHECK_REC (rec);
}
static gboolean
-parse_spf_mx (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_mx (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- char *host;
+ gchar *host;
CHECK_REC (rec);
}
static gboolean
-parse_spf_all (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_all (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
/* All is 0/0 */
if (rec->in_include) {
}
static gboolean
-parse_spf_ip4 (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_ip4 (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
/* ip4:addr[/mask] */
}
static gboolean
-parse_spf_include (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_include (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- char *domain;
+ gchar *domain;
CHECK_REC (rec);
}
static gboolean
-parse_spf_exp (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_exp (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
CHECK_REC (rec);
}
static gboolean
-parse_spf_redirect (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_redirect (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- char *domain;
+ gchar *domain;
CHECK_REC (rec);
}
static gboolean
-parse_spf_exists (struct worker_task *task, const char *begin, struct spf_record *rec, struct spf_addr *addr)
+parse_spf_exists (struct worker_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
{
struct spf_dns_cb *cb;
- char *host;
+ gchar *host;
CHECK_REC (rec);
}
static void
-reverse_spf_ip (char *ip, int len)
+reverse_spf_ip (gchar *ip, gint len)
{
- char ipbuf[sizeof("255.255.255.255") - 1], *p, *c;
- int t = 0, l = len;
+ gchar ipbuf[sizeof("255.255.255.255") - 1], *p, *c;
+ gint t = 0, l = len;
if (len > sizeof (ipbuf)) {
msg_info ("cannot reverse string of length %d", len);
memcpy (ip, ipbuf, len);
}
-static char *
-expand_spf_macro (struct worker_task *task, struct spf_record *rec, char *begin)
+static gchar *
+expand_spf_macro (struct worker_task *task, struct spf_record *rec, gchar *begin)
{
- char *p, *c, *new, *tmp;
- int len = 0, slen = 0, state = 0;
+ gchar *p, *c, *new, *tmp;
+ gint len = 0, slen = 0, state = 0;
gboolean need_expand = FALSE;
p = begin;
{
struct spf_addr *new = NULL;
gboolean need_shift, res = FALSE;
- char *begin;
+ gchar *begin;
rec->cur_elt = rec->elts[rec->elt_num];
if (rec->cur_elt == NULL) {
#undef NEW_ADDR
static void
-parse_spf_scopes (struct spf_record *rec, char **begin)
+parse_spf_scopes (struct spf_record *rec, gchar **begin)
{
for (;;) {
if (g_ascii_strncasecmp (*begin, SPF_SCOPE_PRA, sizeof (SPF_SCOPE_PRA) - 1) == 0) {
}
static void
-start_spf_parse (struct spf_record *rec, char *begin)
+start_spf_parse (struct spf_record *rec, gchar *begin)
{
/* Skip spaces */
while (g_ascii_isspace (*begin)) {
resolve_spf (struct worker_task *task, spf_cb_t callback)
{
struct spf_record *rec;
- char *domain;
+ gchar *domain;
GList *domains;
rec = memory_pool_alloc0 (task->task_pool, sizeof (struct spf_record));
} spf_action_t;
struct spf_addr {
- uint32_t addr;
- uint32_t mask;
+ guint32 addr;
+ guint32 mask;
spf_mech_t mech;
- char *spf_string;
+ gchar *spf_string;
};
struct spf_record {
- char **elts;
+ gchar **elts;
- char *cur_elt;
- int elt_num;
- int nested;
- int dns_requests;
+ gchar *cur_elt;
+ gint elt_num;
+ gint nested;
+ gint dns_requests;
GList *addrs;
- char *cur_domain;
- char *sender;
- char *sender_domain;
- char *local_part;
+ gchar *cur_domain;
+ gchar *sender;
+ gchar *sender_domain;
+ gchar *local_part;
struct worker_task *task;
spf_cb_t callback;
#define STATFILES_MAX 255
static void statfile_pool_set_block_common (
statfile_pool_t * pool, stat_file_t * file,
- uint32_t h1, uint32_t h2,
+ guint32 h1, guint32 h2,
time_t t, double value,
gboolean from_now);
-static int
+static gint
cmpstatfile (const void *a, const void *b)
{
const stat_file_t *s1 = a, *s2 = b;
u_char magic[3]; /**< magic signature ('r' 's' 'd') */
u_char version[2]; /**< version of statfile */
u_char padding[3]; /**< padding */
- uint64_t create_time; /**< create time (time_t->uint64_t) */
+ guint64 create_time; /**< create time (time_t->guint64) */
};
static gboolean
convert_statfile_10 (stat_file_t * file)
{
- char *backup_name;
+ gchar *backup_name;
struct stat st;
struct stat_file_header header = {
.magic = {'r', 's', 'd'},
}
/* Check whether specified file is statistic file and calculate its len in blocks */
-static int
+static gint
statfile_pool_check (stat_file_t * file)
{
struct stat_file *f;
- char *c;
- static char valid_version[] = RSPAMD_STATFILE_VERSION;
+ gchar *c;
+ static gchar valid_version[] = RSPAMD_STATFILE_VERSION;
if (!file || !file->map) {
struct expiration_data {
statfile_pool_t *pool;
- uint64_t oldest;
- char *filename;
+ guint64 oldest;
+ gchar *filename;
};
-static int
+static gint
statfile_pool_expire (statfile_pool_t * pool)
{
struct expiration_data exp;
stat_file_t *file;
- int i;
+ gint i;
if (pool->opened == 0) {
return -1;
for (i = 0; i < pool->opened; i++) {
file = &pool->files[i];
- if ((uint64_t) file->access_time < exp.oldest) {
+ if ((guint64) file->access_time < exp.oldest) {
exp.oldest = file->access_time;
exp.filename = file->filename;
}
}
static stat_file_t *
-statfile_pool_reindex (statfile_pool_t * pool, char *filename, size_t old_size, size_t size)
+statfile_pool_reindex (statfile_pool_t * pool, gchar *filename, size_t old_size, size_t size)
{
- char *backup;
- int fd;
+ gchar *backup;
+ gint fd;
stat_file_t *new;
u_char *map, *pos;
struct stat_file_block *block;
}
stat_file_t *
-statfile_pool_open (statfile_pool_t * pool, char *filename, size_t size, gboolean forced)
+statfile_pool_open (statfile_pool_t * pool, gchar *filename, size_t size, gboolean forced)
{
struct stat st;
stat_file_t *new_file;
return statfile_pool_is_open (pool, filename);
}
-int
+gint
statfile_pool_close (statfile_pool_t * pool, stat_file_t * file, gboolean keep_sorted)
{
stat_file_t *pos;
return 0;
}
-int
-statfile_pool_create (statfile_pool_t * pool, char *filename, size_t size)
+gint
+statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
{
struct stat_file_header header = {
.magic = {'r', 's', 'd'},
.code = STATFILE_SECTION_COMMON,
};
struct stat_file_block block = { 0, 0, 0 };
- int fd;
- unsigned int buflen = 0, nblocks;
- char *buf = NULL;
+ 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);
return -1;
}
- header.create_time = (uint64_t) time (NULL);
+ 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));
close (fd);
return -1;
}
- section.length = (uint64_t) nblocks;
+ 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));
close (fd);
void
statfile_pool_delete (statfile_pool_t * pool)
{
- int 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, uint32_t h1, uint32_t 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;
struct stat_file_header *header;
- unsigned int i, blocknum;
+ guint i, blocknum;
u_char *c;
#define RANDOM_EXPIRE G_MAXINT / CHAIN_LENGTH
static void
-statfile_pool_set_block_common (statfile_pool_t * pool, stat_file_t * file, uint32_t h1, uint32_t 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;
- unsigned int i, blocknum;
+ guint i, blocknum;
u_char *c;
double min = G_MAXDOUBLE;
}
void
-statfile_pool_set_block (statfile_pool_t * pool, stat_file_t * file, uint32_t h1, uint32_t 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 *
-statfile_pool_is_open (statfile_pool_t * pool, char *filename)
+statfile_pool_is_open (statfile_pool_t * pool, gchar *filename)
{
static stat_file_t f, *ret;
g_strlcpy (f.filename, filename, sizeof (f.filename));
return ret;
}
-uint32_t
+guint32
statfile_pool_get_section (statfile_pool_t * pool, stat_file_t * file)
{
}
gboolean
-statfile_pool_set_section (statfile_pool_t * pool, stat_file_t * file, uint32_t 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;
cur_offset = file->seek_pos - sizeof (struct stat_file_section);
}
while (cur_offset < file->len) {
- sec = (struct stat_file_section *)((char *)file->map + cur_offset);
+ sec = (struct stat_file_section *)((gchar *)file->map + cur_offset);
if (sec->code == code) {
file->cur_section.code = code;
file->cur_section.length = sec->length;
}
gboolean
-statfile_pool_add_section (statfile_pool_t * pool, stat_file_t * file, uint32_t code, uint64_t 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 };
file->len += length;
if (file->len > pool->max) {
- msg_info ("cannot attach file to pool, too large: %lu", (long int)file->len);
+ msg_info ("cannot attach file to pool, too large: %z", file->len);
return FALSE;
}
}
-uint32_t
-statfile_get_section_by_name (const char *name)
+guint32
+statfile_get_section_by_name (const gchar *name)
{
if (g_ascii_strcasecmp (name, "common") == 0) {
return STATFILE_SECTION_COMMON;
}
gboolean
-statfile_set_revision (stat_file_t *file, uint64_t rev, time_t time)
+statfile_set_revision (stat_file_t *file, guint64 rev, time_t time)
{
struct stat_file_header *header;
}
gboolean
-statfile_get_revision (stat_file_t *file, uint64_t *rev, time_t *time)
+statfile_get_revision (stat_file_t *file, guint64 *rev, time_t *time)
{
struct stat_file_header *header;
return TRUE;
}
-uint64_t
+guint64
statfile_get_used_blocks (stat_file_t *file)
{
struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
- return (uint64_t)-1;
+ return (guint64)-1;
}
header = (struct stat_file_header *)file->map;
return header->used_blocks;
}
-uint64_t
+guint64
statfile_get_total_blocks (stat_file_t *file)
{
struct stat_file_header *header;
if (file == NULL || file->map == NULL) {
- return (uint64_t)-1;
+ return (guint64)-1;
}
header = (struct stat_file_header *)file->map;
}
static void
-statfile_pool_invalidate_callback (int fd, short what, void *ud)
+statfile_pool_invalidate_callback (gint fd, short what, void *ud)
{
statfile_pool_t *pool = ud;
stat_file_t *file;
- int i;
+ gint i;
msg_info ("invalidating %d statfiles", pool->opened);
pool->invalidate_tv.tv_usec = 0;
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", (int)pool->invalidate_tv.tv_sec);
+ msg_info ("invalidate of statfile pool is planned in %d seconds", (gint)pool->invalidate_tv.tv_sec);
}
}
u_char magic[3]; /**< magic signature ('r' 's' 'd') */
u_char version[2]; /**< version of statfile */
u_char padding[3]; /**< padding */
- uint64_t create_time; /**< create time (time_t->uint64_t) */
- uint64_t revision; /**< revision number */
- uint64_t rev_time; /**< revision time */
- uint64_t used_blocks; /**< used blocks number */
- uint64_t total_blocks; /**< total number of blocks */
+ 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 {
- uint64_t code; /**< section's code */
- uint64_t 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 {
- uint32_t hash1; /**< hash1 (also acts as index) */
- uint32_t hash2; /**< hash2 */
+ guint32 hash1; /**< hash1 (also acts as index) */
+ guint32 hash2; /**< hash2 */
double value; /**< double value */
};
*/
typedef struct stat_file_s {
#ifdef HAVE_PATH_MAX
- char filename[PATH_MAX]; /**< name of file */
+ gchar filename[PATH_MAX]; /**< name of file */
#else
- char filename[MAXPATHLEN]; /**< name of file */
+ gchar filename[MAXPATHLEN]; /**< name of file */
#endif
- int fd; /**< descriptor */
+ gint fd; /**< descriptor */
void *map; /**< mmaped area */
off_t seek_pos; /**< current seek position */
struct stat_file_section cur_section; /**< current section */
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 */
- int opened; /**< number of opened files */
+ gint opened; /**< number of opened files */
size_t max; /**< maximum size */
size_t occupied; /**< current size */
memory_pool_t *pool; /**< memory pool object */
* @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, char *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 len length of new statfile
* @return 0 if file was created and -1 in case of error
*/
-int statfile_pool_create (statfile_pool_t *pool, char *filename, size_t len);
+gint statfile_pool_create (statfile_pool_t *pool, gchar *filename, size_t len);
/**
* Close specified statfile
* @param remove_hash remove filename from opened files hash also
* @return 0 if file was closed and -1 if statfile was not opened
*/
-int 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, uint32_t h1, uint32_t 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, uint32_t h1, uint32_t 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, char *filename);
+stat_file_t* statfile_pool_is_open (statfile_pool_t *pool, gchar *filename);
/**
* Returns current statfile section
* @param filename name of statfile
* @return code of section or 0 if file is not opened
*/
-uint32_t statfile_pool_get_section (statfile_pool_t *pool, stat_file_t *file);
+guint32 statfile_pool_get_section (statfile_pool_t *pool, stat_file_t *file);
/**
* Go to other section of statfile
* @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, uint32_t 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, uint32_t code, uint64_t length);
+gboolean statfile_pool_add_section (statfile_pool_t *pool, stat_file_t *file, guint32 code, guint64 length);
/**
* @param name name of section
* @return code of section or 0 if name of section is unknown
*/
-uint32_t statfile_get_section_by_name (const char *name);
+guint32 statfile_get_section_by_name (const gchar *name);
/**
* Set statfile revision and revision time
* @param time time of revision
* @return TRUE if revision was set
*/
-gboolean statfile_set_revision (stat_file_t *file, uint64_t rev, time_t time);
+gboolean statfile_set_revision (stat_file_t *file, guint64 rev, time_t time);
/**
* Set statfile revision and revision time
* @param time saved time of revision
* @return TRUE if revision was saved in rev and time
*/
-gboolean statfile_get_revision (stat_file_t *file, uint64_t *rev, time_t *time);
+gboolean statfile_get_revision (stat_file_t *file, guint64 *rev, time_t *time);
/**
* Get statfile used blocks
* @param file file to get number of used blocks
- * @return number of used blocks or (uint64_t)-1 in case of error
+ * @return number of used blocks or (guint64)-1 in case of error
*/
-uint64_t statfile_get_used_blocks (stat_file_t *file);
+guint64 statfile_get_used_blocks (stat_file_t *file);
/**
* Get statfile total blocks
* @param file file to get number of used blocks
- * @return number of used blocks or (uint64_t)-1 in case of error
+ * @return number of used blocks or (guint64)-1 in case of error
*/
-uint64_t statfile_get_total_blocks (stat_file_t *file);
+guint64 statfile_get_total_blocks (stat_file_t *file);
/**
struct timeval interval;
struct timeval io_tv;
- int sock;
+ gint sock;
enum rspamd_sync_state state;
gboolean is_busy;
- uint64_t new_rev;
- uint64_t new_time;
- uint64_t new_len;
+ guint64 new_rev;
+ guint64 new_time;
+ guint64 new_len;
};
static void
-log_next_sync (const char *symbol, time_t delay)
+log_next_sync (const gchar *symbol, time_t delay)
{
- char outstr[200];
+ gchar outstr[200];
time_t t;
struct tm *tmp;
- int r;
+ gint r;
t = time(NULL);
t += delay;
static gboolean
parse_revision_line (struct rspamd_sync_ctx *ctx, f_str_t *in)
{
- int i, state = 0;
- char *p, *c, numbuf[sizeof("18446744073709551615")];
- uint64_t *val;
+ gint 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) {
read_blocks (struct rspamd_sync_ctx *ctx, f_str_t *in)
{
struct rspamd_binlog_element *elt;
- int i;
+ gint i;
statfile_pool_lock_file (ctx->pool, ctx->real_statfile);
elt = (struct rspamd_binlog_element *)in->begin;
sync_read (f_str_t * in, void *arg)
{
struct rspamd_sync_ctx *ctx = arg;
- char buf[256];
- uint64_t rev = 0;
+ gchar buf[256];
+ guint64 rev = 0;
time_t ti = 0;
if (in->len == 0) {
/* 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 %l %l" CRLF, ctx->st->symbol, (long int)rev, (long int)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, (int)in->len, in->begin);
+ 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;
}
statfile_set_revision (ctx->real_statfile, ctx->new_rev, ctx->new_time);
- msg_info ("set new revision: %ul, readed %ul bytes", (long unsigned)ctx->new_rev, (long unsigned)in->len);
+ 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);
static void
-sync_timer_callback (int fd, short what, void *ud)
+sync_timer_callback (gint fd, short what, void *ud)
{
struct rspamd_sync_ctx *ctx = ud;
#define MIN_CACHE 17
-static uint64_t total_frequency = 0;
-static uint32_t nsymbols = 0;
+static guint64 total_frequency = 0;
+static guint32 nsymbols = 0;
-int
+gint
cache_cmp (const void *p1, const void *p2)
{
const struct cache_item *i1 = p1, *i2 = p2;
return strcmp (i1->s->symbol, i2->s->symbol);
}
-int
+gint
cache_logic_cmp (const void *p1, const void *p2)
{
const struct cache_item *i1 = p1, *i2 = p2;
w1 = abs (i1->s->weight) * WEIGHT_MULT + f1 * FREQUENCY_MULT + i1->s->avg_time * TIME_MULT;
w2 = abs (i2->s->weight) * WEIGHT_MULT + f2 * FREQUENCY_MULT + i2->s->avg_time * TIME_MULT;
- return (int)w2 - w1;
+ return (gint)w2 - w1;
}
static GChecksum *
}
static gboolean
-mmap_cache_file (struct symbols_cache *cache, int fd, memory_pool_t *pool)
+mmap_cache_file (struct symbols_cache *cache, gint fd, memory_pool_t *pool)
{
guint8 *map;
- int i;
+ gint i;
GList *cur;
struct cache_item *item;
/* Fd must be opened for writing, after creating file is mmapped */
static gboolean
-create_cache_file (struct symbols_cache *cache, const char *filename, int fd, memory_pool_t *pool)
+create_cache_file (struct symbols_cache *cache, const gchar *filename, gint fd, memory_pool_t *pool)
{
GChecksum *cksum;
u_char *digest;
}
void
-register_symbol (struct symbols_cache **cache, const char *name, double weight, symbol_func_t func, gpointer user_data)
+register_symbol (struct symbols_cache **cache, const gchar *name, double weight, symbol_func_t func, gpointer user_data)
{
struct cache_item *item = NULL;
struct symbols_cache *pcache = *cache;
void
register_dynamic_symbol (memory_pool_t *dynamic_pool, struct symbols_cache **cache,
- const char *name, double weight, symbol_func_t func,
+ const gchar *name, double weight, symbol_func_t func,
gpointer user_data, GList *networks)
{
struct cache_item *item = NULL;
GList *t, *cur;
uintptr_t r;
double *w;
- uint32_t mask = 0xFFFFFFFF;
+ guint32 mask = 0xFFFFFFFF;
struct dynamic_map_item *it;
if (*cache == NULL) {
}
gboolean
-init_symbols_cache (memory_pool_t * pool, struct symbols_cache *cache, struct config_file *cfg, const char *filename)
+init_symbols_cache (memory_pool_t * pool, struct symbols_cache *cache, struct config_file *cfg, const gchar *filename)
{
struct stat st;
- int fd;
+ gint fd;
GChecksum *cksum;
u_char *mem_sum, *file_sum;
gsize cklen;
}
static gboolean
-check_debug_symbol (struct config_file *cfg, const char *symbol)
+check_debug_symbol (struct config_file *cfg, const gchar *symbol)
{
GList *cur;
cur = cfg->debug_symbols;
while (cur) {
- if (strcmp (symbol, (const char *)cur->data) == 0) {
+ if (strcmp (symbol, (const gchar *)cur->data) == 0) {
return TRUE;
}
cur = g_list_next (cur);
#else
struct timeval tv1, tv2;
#endif
- uint64_t diff;
+ guint64 diff;
struct cache_item *item = NULL;
struct symbol_callback_data *s = *save;
typedef void (*symbol_func_t)(struct worker_task *task, gpointer user_data);
struct saved_cache_item {
- char symbol[MAX_SYMBOL];
+ gchar symbol[MAX_SYMBOL];
double weight;
- uint32_t frequency;
+ guint32 frequency;
double avg_time;
};
struct dynamic_map_item {
struct in_addr addr;
- uint32_t mask;
+ guint32 mask;
gboolean negative;
};
/* For dynamic rules */
struct dynamic_map_item *networks;
- uint32_t networks_number;
+ guint32 networks_number;
gboolean is_dynamic;
/* Callback data */
/**
* Load symbols cache from file, must be called _after_ init_symbols_cache
*/
-gboolean init_symbols_cache (memory_pool_t *pool, struct symbols_cache *cache, struct config_file *cfg, const char *filename);
+gboolean init_symbols_cache (memory_pool_t *pool, struct symbols_cache *cache, struct config_file *cfg, const gchar *filename);
/**
* 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 char *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 function for dynamic symbols parsing
* @param func pointer to handler
* @param user_data pointer to user_data
*/
-void register_dynamic_symbol (memory_pool_t *pool, struct symbols_cache **cache, const char *name,
+void register_dynamic_symbol (memory_pool_t *pool, struct symbols_cache **cache, const gchar *name,
double weight, symbol_func_t func,
gpointer user_data, GList *networks);
c = trie->icase ? g_ascii_tolower (*p) : *p;
m = check_match (q, c);
if (m == NULL) {
- /* Insert char at specified level depth */
+ /* Insert gchar at specified level depth */
q = rspamd_trie_insert_char (trie, depth, q, c);
}
else {
* Init: 0x0
*/
-static const uint32_t crc32lookup[256] = {
+static const guint32 crc32lookup[256] = {
0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, 0x706af48fU,
0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU, 0x97d2d988U,
0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U,
void
revive_all_upstreams (void *ups, size_t members, size_t msize)
{
- int i;
+ gint i;
struct upstream *cur;
u_char *p;
* Scan all upstreams for errors and mark upstreams dead or alive depends on conditions,
* return number of alive upstreams
*/
-static int
+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)
{
- int i, alive;
+ gint i, alive;
struct upstream *cur;
u_char *p;
/* Return alive upstream by its number */
static struct upstream *
-get_upstream_by_number (void *ups, size_t members, size_t msize, int selected)
+get_upstream_by_number (void *ups, size_t members, size_t msize, gint selected)
{
- int i;
+ gint i;
u_char *p, *c;
struct upstream *cur;
/*
* Get hash key for specified key (perl hash)
*/
-static uint32_t
-get_hash_for_key (uint32_t hash, char *key, size_t keylen)
+static guint32
+get_hash_for_key (guint32 hash, gchar *key, size_t keylen)
{
- uint32_t h, index;
- const char *end = key + keylen;
+ guint32 h, index;
+ const gchar *end = key + keylen;
h = ~hash;
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)
{
- int alive, selected;
+ gint alive, selected;
alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
selected = rand () % alive;
* 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, char *key, size_t keylen)
+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, gchar *key, size_t keylen)
{
- int alive, tries = 0, r;
- uint32_t h = 0, ht;
- char *p, numbuf[4];
+ 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);
h %= members;
for (;;) {
- p = (char *)ups + msize * h;
+ p = (gchar *)ups + msize * h;
cur = (struct upstream *)p;
if (!cur->dead) {
break;
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)
{
- int alive, max_weight, i;
+ gint alive, max_weight, i;
struct upstream *cur, *selected = NULL;
u_char *p;
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)
{
- int alive, max_weight, i;
+ gint alive, max_weight, i;
struct upstream *cur, *selected = NULL;
u_char *p;
* Ketama manipulation functions
*/
-static int
+static gint
ketama_sort_cmp (const void *a1, const void *a2)
{
- return *((uint32_t *) a1) - *((uint32_t *) a2);
+ return *((guint32 *) a1) - *((guint32 *) a2);
}
/*
* Add ketama points for specified upstream
*/
-int
-upstream_ketama_add (struct upstream *up, char *up_key, size_t keylen, size_t keypoints)
+gint
+upstream_ketama_add (struct upstream *up, gchar *up_key, size_t keylen, size_t keypoints)
{
- uint32_t h = 0;
- char tmp[4];
- int i;
+ guint32 h = 0;
+ gchar tmp[4];
+ gint i;
/* Allocate ketama points array */
if (up->ketama_points == NULL) {
up->ketama_points_size = keypoints;
- up->ketama_points = malloc (sizeof (uint32_t) * up->ketama_points_size);
+ up->ketama_points = malloc (sizeof (guint32) * up->ketama_points_size);
if (up->ketama_points == NULL) {
return -1;
}
tmp[2] = (i >> 16) & 0xff;
tmp[3] = (i >> 24) & 0xff;
- h = get_hash_for_key (h, tmp, sizeof (tmp) * sizeof (char));
+ h = get_hash_for_key (h, tmp, sizeof (tmp) * sizeof (gchar));
up->ketama_points[i] = h;
}
/* Keep points sorted */
- qsort (up->ketama_points, keypoints, sizeof (uint32_t), ketama_sort_cmp);
+ qsort (up->ketama_points, keypoints, sizeof (guint32), ketama_sort_cmp);
return 0;
}
* 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, char *key, size_t keylen)
+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, gchar *key, size_t keylen)
{
- int alive, i;
- uint32_t h = 0, step, middle, d, min_diff = UINT_MAX;
- char *p;
+ gint 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);
#include <stdint.h>
struct upstream {
- unsigned int errors;
+ guint errors;
time_t time;
- unsigned char dead;
- unsigned char priority;
- int16_t weight;
- uint32_t *ketama_points;
+ guint dead;
+ guint priority;
+ gint16 weight;
+ guint32 *ketama_points;
size_t ketama_points_size;
};
void upstream_fail (struct upstream *up, time_t now);
void upstream_ok (struct upstream *up, time_t now);
void revive_all_upstreams (void *ups, size_t members, size_t msize);
-int upstream_ketama_add (struct upstream *up, char *up_key, size_t keylen, size_t keypoints);
+gint upstream_ketama_add (struct upstream *up, gchar *up_key, size_t keylen, size_t keypoints);
struct upstream* get_random_upstream (void *ups, size_t members, size_t msize,
time_t now, time_t error_timeout,
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,
- char *key, size_t keylen);
+ gchar *key, size_t keylen);
struct upstream* get_upstream_round_robin (void *ups, size_t members, size_t msize,
time_t now, time_t error_timeout,
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,
- char *key, size_t keylen);
+ gchar *key, size_t keylen);
#endif /* UPSTREAM_H */
(LOWEST_PORT <= (port) && (port) <= HIGHEST_PORT)
struct _proto {
- unsigned char *name;
- int port;
+ guchar *name;
+ gint port;
uintptr_t *unused;
- unsigned int need_slashes:1;
- unsigned int need_slash_after_host:1;
- unsigned int free_syntax:1;
- unsigned int need_ssl:1;
+ guint need_slashes:1;
+ guint need_slash_after_host:1;
+ guint free_syntax:1;
+ guint need_ssl:1;
};
typedef struct url_match_s {
#define is_urlsafe(x) ((url_scanner_table[(guchar)(x)] & (IS_ALPHA|IS_DIGIT|IS_URLSAFE)) != 0)
-static const char *
+static const gchar *
url_strerror (enum uri_errno err)
{
switch (err) {
return NULL;
}
-static inline int
-end_of_dir (unsigned char c)
+static inline gint
+end_of_dir (gchar c)
{
return c == POST_CHAR || c == '#' || c == ';' || c == '?';
}
-static inline int
-is_uri_dir_sep (struct uri *uri, unsigned char pos)
+static inline gint
+is_uri_dir_sep (struct uri *uri, gchar pos)
{
return (pos == '/');
}
-static int
-check_uri_file (unsigned char *name)
+static gint
+check_uri_file (gchar *name)
{
- static const unsigned char chars[] = POST_CHAR_S "#?";
+ static const gchar chars[] = POST_CHAR_S "#?";
return strcspn (name, chars);
}
-static int
+static gint
url_init (void)
{
- int i;
+ gint i;
if (url_scanner == NULL) {
url_scanner = g_malloc (sizeof (struct url_match_scanner));
url_scanner->matchers = matchers;
}
enum protocol
-get_protocol (unsigned char *name, int namelen)
+get_protocol (gchar *name, gint namelen)
{
/* 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. */
- int start, end;
+ gint start, end;
enum protocol protocol;
- unsigned char *pname;
- int pnamelen, minlen, compare;
+ 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
}
-int
+gint
get_protocol_port (enum protocol protocol)
{
return protocol_backends[protocol].port;
}
-int
+gint
get_protocol_need_slashes (enum protocol protocol)
{
return protocol_backends[protocol].need_slashes;
}
-int
+gint
get_protocol_need_slash_after_host (enum protocol protocol)
{
return protocol_backends[protocol].need_slash_after_host;
}
-int
+gint
get_protocol_free_syntax (enum protocol protocol)
{
return protocol_backends[protocol].free_syntax;
}
-static int
-get_protocol_length (const unsigned char *url)
+static gint
+get_protocol_length (const gchar *url)
{
- unsigned char *end = (unsigned char *)url;
+ gchar *end = (gchar *)url;
/* Seek the end of the protocol name if any. */
/* RFC1738:
/*
* Calcualte new length of unescaped hostlen
*/
-static unsigned int
-url_calculate_escaped_hostlen (char *host, unsigned int hostlen)
+static guint
+url_calculate_escaped_hostlen (gchar *host, guint hostlen)
{
- unsigned int i, result = hostlen;
- char *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) {
string intact, make a copy before calling this function. */
static void
-url_unescape (char *s)
+url_unescape (gchar *s)
{
- char *t = s; /* t - tortoise */
- char *h = s; /* h - hare */
+ gchar *t = s; /* t - tortoise */
+ gchar *h = s; /* h - hare */
for (; *h; h++, t++) {
if (*h != '%') {
*t = *h;
}
else {
- char 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])))
goto copychar;
}
static void
-url_strip (char *s)
+url_strip (gchar *s)
{
- char *t = s; /* t - tortoise */
- char *h = s; /* h - hare */
+ gchar *t = s; /* t - tortoise */
+ gchar *h = s; /* h - hare */
while (*h) {
if (g_ascii_isgraph (*h)) {
*t = '\0';
}
-static char *
-url_escape_1 (const char *s, int allow_passthrough, memory_pool_t * pool)
+static gchar *
+url_escape_1 (const gchar *s, gint allow_passthrough, memory_pool_t * pool)
{
- const char *p1;
- char *p2, *newstr;
- int newlen;
- int addition = 0;
+ const gchar *p1;
+ gchar *p2, *newstr;
+ gint newlen;
+ gint addition = 0;
for (p1 = s; *p1; p1++)
if (!is_urlsafe (*p1)) {
if (!addition) {
if (allow_passthrough) {
- return (char *)s;
+ return (gchar *)s;
}
else {
return memory_pool_strdup (pool, s);
}
newlen = (p1 - s) + addition;
- newstr = (char *)memory_pool_alloc (pool, newlen + 1);
+ newstr = (gchar *)memory_pool_alloc (pool, newlen + 1);
p1 = s;
p2 = newstr;
while (*p1) {
/* Quote the characters that match the test mask. */
if (!is_urlsafe (*p1)) {
- unsigned char 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. */
-char *
-url_escape (const char *s, memory_pool_t * pool)
+gchar *
+url_escape (const gchar *s, memory_pool_t * pool)
{
return url_escape_1 (s, 0, pool);
}
/* URL-escape the unsafe characters (see urlchr_table) in a given
string. If no characters are unsafe, S is returned. */
-static char *
-url_escape_allow_passthrough (const char *s, memory_pool_t * pool)
+static gchar *
+url_escape_allow_passthrough (const gchar *s, memory_pool_t * pool)
{
return url_escape_1 (s, 1, pool);
}
-/* Decide whether the char at position P needs to be encoded. (It is
- not enough to pass a single char *P because the function may need
+/* Decide whether the gchar at position P needs to be encoded. (It is
+ not enough to pass a single gchar *P because the function may need
to inspect the surrounding context.)
- Return 1 if the char should be escaped as %XX, 0 otherwise. */
+ Return 1 if the gchar should be escaped as %XX, 0 otherwise. */
-static inline int
-char_needs_escaping (const char *p)
+static inline gint
+char_needs_escaping (const gchar *p)
{
if (*p == '%') {
if (g_ascii_isxdigit (*(p + 1)) && g_ascii_isxdigit (*(p + 2)))
further transformations of the result yield the same output.
*/
-static char *
-reencode_escapes (char *s, memory_pool_t * pool)
+static gchar *
+reencode_escapes (gchar *s, memory_pool_t * pool)
{
- const char *p1;
- char *newstr, *p2;
- int oldlen, newlen;
+ const gchar *p1;
+ gchar *newstr, *p2;
+ gint oldlen, newlen;
- int 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)) {
- unsigned char c = *p1++;
+ guchar c = *p1++;
*p2++ = '%';
*p2++ = XNUM_TO_DIGIT (c >> 4);
*p2++ = XNUM_TO_DIGIT (c & 0xf);
count of unescaped chars. */
static void
-unescape_single_char (char *str, char chr)
+unescape_single_char (gchar *str, gchar chr)
{
- const char c1 = XNUM_TO_DIGIT (chr >> 4);
- const char c2 = XNUM_TO_DIGIT (chr & 0xf);
- char *h = str; /* hare */
- char *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) {
/* Escape unsafe and reserved characters, except for the slash
characters. */
-static char *
-url_escape_dir (const char *dir, memory_pool_t * pool)
+static gchar *
+url_escape_dir (const gchar *dir, memory_pool_t * pool)
{
- char *newdir = url_escape_1 (dir, 1, pool);
+ gchar *newdir = url_escape_1 (dir, 1, pool);
if (newdir == dir)
- return (char *)dir;
+ return (gchar *)dir;
unescape_single_char (newdir, '/');
return newdir;
function, run test_path_simplify to make sure you haven't broken a
test case. */
-static int
-path_simplify (char *path)
+static gint
+path_simplify (gchar *path)
{
- char *h = path; /* hare */
- char *t = path; /* tortoise */
- char *beg = path; /* boundary for backing the tortoise */
- char *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. */
}
enum uri_errno
-parse_uri (struct uri *uri, unsigned char *uristring, memory_pool_t * pool)
+parse_uri (struct uri *uri, gchar *uristring, memory_pool_t * pool)
{
- unsigned char *prefix_end, *host_end, *p;
- unsigned char *lbracket, *rbracket;
- int datalen, n, addrlen;
- unsigned char *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));
{
const gchar *p;
gchar stop;
- int i;
+ gint i;
p = pos + strlen (match->pattern);
if (*p == '/') {
{
const gchar *p, *c;
gchar open_brace = '\0', close_brace = '\0';
- int i, brace_stack;
+ gint i, brace_stack;
gboolean passwd;
guint port;
url_parse_text (memory_pool_t * pool, struct worker_task *task, struct mime_text_part *part, gboolean is_html)
{
struct url_matcher *matcher;
- int rc, idx;
- char *url_str = NULL;
+ gint rc, idx;
+ gchar *url_str = NULL;
struct uri *new;
const guint8 *p, *end, *pos;
url_match_t m;
struct uri {
/* The start of the uri (and thus start of the protocol string). */
- unsigned char *string;
+ gchar *string;
/* The internal type of protocol. Can _never_ be PROTOCOL_UNKNOWN. */
- int protocol; /* enum protocol */
+ gint protocol; /* enum protocol */
- int ip_family;
+ gint ip_family;
- unsigned char *user;
- unsigned char *password;
- unsigned char *host;
- unsigned char *port;
+ gchar *user;
+ gchar *password;
+ gchar *host;
+ gchar *port;
/* @data can contain both the path and query uri fields.
* It can never be NULL but can have zero length. */
- unsigned char *data;
- unsigned char *fragment;
+ gchar *data;
+ gchar *fragment;
/* @post can contain some special encoded form data, used internally
* to make form data handling more efficient. The data is marked by
* POST_CHAR in the uri string. */
- unsigned char *post;
+ gchar *post;
/* @protocollen should only be usable if @protocol is either
* PROTOCOL_USER or an uri string should be composed. */
- unsigned int protocollen;
- unsigned int userlen;
- unsigned int passwordlen;
- unsigned int hostlen;
- unsigned int portlen;
- unsigned int datalen;
- unsigned int fragmentlen;
+ guint protocollen;
+ guint userlen;
+ guint passwordlen;
+ guint hostlen;
+ guint portlen;
+ guint datalen;
+ guint fragmentlen;
/* Flags */
- unsigned int ipv6; /* URI contains IPv6 host */
- unsigned int form; /* URI originated from form */
+ guint ipv6; /* URI contains IPv6 host */
+ guint form; /* URI originated from form */
};
enum uri_errno {
#define struri(uri) ((uri)->string)
void url_parse_text (memory_pool_t *pool, struct worker_task *task, struct mime_text_part *part, gboolean is_html);
-enum uri_errno parse_uri(struct uri *uri, unsigned char *uristring, memory_pool_t *pool);
+enum uri_errno parse_uri(struct uri *uri, gchar *uristring, memory_pool_t *pool);
#endif
extern rspamd_hash_t *counters;
#endif
-static u_char* rspamd_sprintf_num (u_char *buf, u_char *last, uint64_t ui64, u_char zero, unsigned int hexadecimal, unsigned int width);
+static gchar* rspamd_sprintf_num (gchar *buf, gchar *last, guint64 ui64, gchar zero, guint hexadecimal, guint width);
-int
-make_socket_nonblocking (int fd)
+gint
+make_socket_nonblocking (gint fd)
{
- int ofl;
+ gint ofl;
ofl = fcntl (fd, F_GETFL, 0);
return 0;
}
-int
-make_socket_blocking (int fd)
+gint
+make_socket_blocking (gint fd)
{
- int ofl;
+ gint ofl;
ofl = fcntl (fd, F_GETFL, 0);
return 0;
}
-int
-poll_sync_socket (int fd, int timeout, short events)
+gint
+poll_sync_socket (gint fd, gint timeout, short events)
{
- int r;
+ gint r;
struct pollfd fds[1];
fds->fd = fd;
return r;
}
-static int
-make_inet_socket (int family, struct in_addr *addr, u_short port, gboolean is_server, gboolean async)
+static gint
+make_inet_socket (gint family, struct in_addr *addr, u_short port, gboolean is_server, gboolean async)
{
- int fd, r, optlen, on = 1, s_error;
- int serrno;
+ gint fd, r, optlen, on = 1, s_error;
+ gint serrno;
struct sockaddr_in sin;
/* Create socket */
sin.sin_addr.s_addr = addr->s_addr;
if (is_server) {
- setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (int));
+ setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (gint));
r = bind (fd, (struct sockaddr *)&sin, sizeof (struct sockaddr_in));
}
else {
return (-1);
}
-int
+gint
make_tcp_socket (struct in_addr *addr, u_short port, gboolean is_server, gboolean async)
{
return make_inet_socket (SOCK_STREAM, addr, port, is_server, async);
}
-int
+gint
make_udp_socket (struct in_addr *addr, u_short port, gboolean is_server, gboolean async)
{
return make_inet_socket (SOCK_DGRAM, addr, port, is_server, async);
}
-int
-accept_from_socket (int listen_sock, struct sockaddr *addr, socklen_t * len)
+gint
+accept_from_socket (gint listen_sock, struct sockaddr *addr, socklen_t * len)
{
- int nfd;
- int serrno;
+ gint nfd;
+ gint serrno;
if ((nfd = accept (listen_sock, addr, len)) == -1) {
if (errno == EAGAIN) {
}
-int
-make_unix_socket (const char *path, struct sockaddr_un *addr, gboolean is_server)
+gint
+make_unix_socket (const gchar *path, struct sockaddr_un *addr, gboolean is_server)
{
- int fd, s_error, r, optlen, serrno, on = 1;
+ gint fd, s_error, r, optlen, serrno, on = 1;
if (path == NULL)
return -1;
goto out;
}
if (is_server) {
- setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (int));
+ setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (gint));
r = bind (fd, (struct sockaddr *)addr, SUN_LEN (addr));
}
else {
return (-1);
}
-int
+gint
write_pid (struct rspamd_main *main)
{
pid_t pid;
#ifdef HAVE_SA_SIGINFO
void
-init_signals (struct sigaction *signals, void (*sig_handler)(int, siginfo_t *, void *))
+init_signals (struct sigaction *signals, void (*sig_handler)(gint, siginfo_t *, void *))
#else
void
init_signals (struct sigaction *signals, sighandler_t sig_handler)
pass_signal_cb (gpointer key, gpointer value, gpointer ud)
{
struct rspamd_worker *cur = value;
- int signo = GPOINTER_TO_INT (ud);
+ gint signo = GPOINTER_TO_INT (ud);
kill (cur->pid, signo);
}
void
-pass_signal_worker (GHashTable * workers, int signo)
+pass_signal_worker (GHashTable * workers, gint signo)
{
g_hash_table_foreach (workers, pass_signal_cb, GINT_TO_POINTER (signo));
}
void
-convert_to_lowercase (char *str, unsigned int size)
+convert_to_lowercase (gchar *str, guint size)
{
while (size--) {
*str = g_ascii_tolower (*str);
#ifndef HAVE_SETPROCTITLE
-static char *title_buffer = 0;
+static gchar *title_buffer = 0;
static size_t title_buffer_size = 0;
-static char *title_progname, *title_progname_full;
+static gchar *title_progname, *title_progname_full;
-int
-setproctitle (const char *fmt, ...)
+gint
+setproctitle (const gchar *fmt, ...)
{
if (!title_buffer || !title_buffer_size) {
errno = ENOMEM;
functions gets called without arguments.
*/
-int
-init_title (int argc, char *argv[], char *envp[])
+gint
+init_title (gint argc, gchar *argv[], gchar *envp[])
{
#if defined(DARWIN) || defined(SOLARIS)
/* XXX: try to handle these OSes too */
return 0;
#else
- char *begin_of_buffer = 0, *end_of_buffer = 0;
- int 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;
- char **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;
- char *p = strrchr (title_progname_full, '/');
+ gchar *p = strrchr (title_progname_full, '/');
if (p)
title_progname = p + 1;
#endif
#ifndef HAVE_PIDFILE
-extern char *__progname;
-static int _pidfile_remove (struct pidfh *pfh, int freeit);
+extern gchar *__progname;
+static gint _pidfile_remove (struct pidfh *pfh, gint freeit);
-static int
+static gint
pidfile_verify (struct pidfh *pfh)
{
struct stat sb;
return 0;
}
-static int
-pidfile_read (const char *path, pid_t * pidptr)
+static gint
+pidfile_read (const gchar *path, pid_t * pidptr)
{
- char buf[16], *endptr;
- int error, fd, i;
+ gchar buf[16], *endptr;
+ gint error, fd, i;
fd = open (path, O_RDONLY);
if (fd == -1)
}
struct pidfh *
-pidfile_open (const char *path, mode_t mode, pid_t * pidptr)
+pidfile_open (const gchar *path, mode_t mode, pid_t * pidptr)
{
struct pidfh *pfh;
struct stat sb;
- int error, fd, len, count;
+ gint error, fd, len, count;
struct timespec rqtp;
pfh = g_malloc (sizeof (*pfh));
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 >= (int)sizeof (pfh->pf_path)) {
+ if (len >= (gint)sizeof (pfh->pf_path)) {
g_free (pfh);
errno = ENAMETOOLONG;
return NULL;
return pfh;
}
-int
+gint
pidfile_write (struct pidfh *pfh)
{
- char pidstr[16];
- int error, fd;
+ gchar pidstr[16];
+ gint error, fd;
/*
* Check remembered descriptor, so we don't overwrite some other
return -1;
}
- snprintf (pidstr, sizeof (pidstr), "%lu", (long unsigned)getpid ());
+ rspamd_snprintf (pidstr, sizeof (pidstr), "%P", getpid ());
if (pwrite (fd, pidstr, strlen (pidstr), 0) != (ssize_t) strlen (pidstr)) {
error = errno;
_pidfile_remove (pfh, 0);
return 0;
}
-int
+gint
pidfile_close (struct pidfh *pfh)
{
- int error;
+ gint error;
error = pidfile_verify (pfh);
if (error != 0) {
return 0;
}
-static int
-_pidfile_remove (struct pidfh *pfh, int freeit)
+static gint
+_pidfile_remove (struct pidfh *pfh, gint freeit)
{
- int error;
+ gint error;
error = pidfile_verify (pfh);
if (error != 0) {
return 0;
}
-int
+gint
pidfile_remove (struct pidfh *pfh)
{
#endif
/* Replace %r with rcpt value and %f with from value, new string is allocated in pool */
-char *
-resolve_stat_filename (memory_pool_t * pool, char *pattern, char *rcpt, char *from)
+gchar *
+resolve_stat_filename (memory_pool_t * pool, gchar *pattern, gchar *rcpt, gchar *from)
{
- int need_to_format = 0, len = 0;
- int rcptlen, fromlen;
- char *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 char *
-calculate_check_time (struct timeval *tv, struct timespec *begin, int resolution)
+const gchar *
+calculate_check_time (struct timeval *tv, struct timespec *begin, gint resolution)
#else
-const char *
-calculate_check_time (struct timeval *begin, int resolution)
+const gchar *
+calculate_check_time (struct timeval *begin, gint resolution)
#endif
{
double vdiff, diff;
- static char res[64];
- static char fmt[sizeof ("%.10f ms real, %.10f ms virtual")];
+ 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));
sprintf (fmt, "%%.%dfms real, %%.%dfms virtual", resolution, resolution);
snprintf (res, sizeof (res), fmt, diff, vdiff);
- return (const char *)res;
+ return (const gchar *)res;
}
double
-set_counter (const char *name, long int value)
+set_counter (const gchar *name, guint32 value)
{
#ifdef RSPAMD_MAIN
struct counter_data *cd;
double alpha;
- char *key;
+ gchar *key;
cd = rspamd_hash_lookup (counters, (gpointer) name);
gboolean
rspamd_strcase_equal (gconstpointer v, gconstpointer v2)
{
- if (g_ascii_strcasecmp ((const char *)v, (const char *)v2) == 0) {
+ if (g_ascii_strcasecmp ((const gchar *)v, (const gchar *)v2) == 0) {
return TRUE;
}
guint
rspamd_strcase_hash (gconstpointer key)
{
- const char *p = key;
+ const gchar *p = key;
guint h = 0;
while (*p != '\0') {
fstr_strcase_hash (gconstpointer key)
{
const f_str_t *f = key;
- const char *p;
+ const gchar *p;
guint h = 0;
p = f->begin;
}
void
-gperf_profiler_init (struct config_file *cfg, const char *descr)
+gperf_profiler_init (struct config_file *cfg, const gchar *descr)
{
#if defined(WITH_GPERF_TOOLS) && defined(RSPAMD_MAIN)
- char prof_path[PATH_MAX];
+ gchar prof_path[PATH_MAX];
if (getenv ("CPUPROFILE")) {
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, (int)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
-lock_file (int fd, gboolean async)
+lock_file (gint fd, gboolean async)
{
- int flags;
+ gint flags;
if (async) {
flags = LOCK_EX | LOCK_NB;
}
gboolean
-unlock_file (int fd, gboolean async)
+unlock_file (gint fd, gboolean async)
{
- int flags;
+ gint flags;
if (async) {
flags = LOCK_UN | LOCK_NB;
#else /* HAVE_FLOCK */
/* Fctnl version */
gboolean
-lock_file (int fd, gboolean async)
+lock_file (gint fd, gboolean async)
{
struct flock fl = {
.l_type = F_WRLCK,
}
gboolean
-unlock_file (int fd, gboolean async)
+unlock_file (gint fd, gboolean async)
{
struct flock fl = {
.l_type = F_UNLCK,
#ifdef RSPAMD_MAIN
stat_file_t *
get_statfile_by_symbol (statfile_pool_t *pool, struct classifier_config *ccf,
- const char *symbol, struct statfile **st, gboolean try_create)
+ const gchar *symbol, struct statfile **st, gboolean try_create)
{
stat_file_t *res = NULL;
GList *cur;
}
#endif /* RSPAMD_MAIN */
-/*
- * supported formats:
- * %[0][width][x][X]O off_t
- * %[0][width]T time_t
- * %[0][width][u][x|X]z ssize_t/size_t
- * %[0][width][u][x|X]d int/u_int
- * %[0][width][u][x|X]l long
- * %[0][width|m][u][x|X]i int/ngx_int_t
- * %[0][width][u][x|X]D int32_t/uint32_t
- * %[0][width][u][x|X]L int64_t/uint64_t
- * %[0][width][.width]f double
- * %[0][width][.width]F long double
- * %[0][width][.width]g double
- * %[0][width][.width]G long double
- * %P pid_t
- * %r rlim_t
- * %p void *
- * %V f_str_t *
- * %s null-terminated string
- * %*s length and string
- * %Z '\0'
- * %N '\n'
- * %c char
- * %% %
- *
- */
+gint
+rspamd_fprintf (FILE *f, const gchar *fmt, ...)
+{
+ gchar *p;
+ va_list args;
+ gchar buf[BUFSIZ];
+ gint r;
+
+ va_start (args, fmt);
+ p = rspamd_vsnprintf (buf, sizeof (buf), fmt, args);
+ va_end (args);
+
+ r = fprintf (f, "%s", buf);
+
+ return r;
+}
-int
-rspamd_sprintf (u_char *buf, const char *fmt, ...)
+gint
+rspamd_sprintf (gchar *buf, const gchar *fmt, ...)
{
- u_char *p;
+ gchar *p;
va_list args;
va_start (args, fmt);
}
-int
-rspamd_snprintf (u_char *buf, size_t max, const char *fmt, ...)
+gint
+rspamd_snprintf (gchar *buf, size_t max, const gchar *fmt, ...)
{
- u_char *p;
+ gchar *p;
va_list args;
va_start (args, fmt);
}
-u_char *
-rspamd_vsnprintf (u_char *buf, size_t max, const char *fmt, va_list args)
+gchar *
+rspamd_vsnprintf (gchar *buf, size_t max, const gchar *fmt, va_list args)
{
- u_char *p, zero, *last;
- int d;
+ gchar *p, zero, *last;
+ gint d;
long double f, scale;
size_t len, slen;
- int64_t i64;
- uint64_t ui64;
- unsigned int width, sign, hex, max_width, frac_width, i;
+ gint64 i64;
+ guint64 ui64;
+ guint width, sign, hex, max_width, frac_width, i;
f_str_t *v;
if (max == 0) {
i64 = 0;
ui64 = 0;
- zero = (u_char) ((*++fmt == '0') ? '0' : ' ');
+ zero = (gchar) ((*++fmt == '0') ? '0' : ' ');
width = 0;
sign = 1;
hex = 0;
break;
case '*':
- d = (int)va_arg (args, int);
+ d = (gint)va_arg (args, gint);
if (G_UNLIKELY (d < 0)) {
msg_err ("crititcal error: size is less than 0");
g_assert (0);
len = v->len;
len = (buf + len < last) ? len : (size_t) (last - buf);
- buf = ((u_char *)memcpy (buf, v->begin, len)) + len;
+ buf = ((gchar *)memcpy (buf, v->begin, len)) + len;
fmt++;
continue;
case 's':
- p = va_arg(args, u_char *);
+ p = va_arg(args, gchar *);
if (p == NULL) {
p = "(NULL)";
}
} else {
len = (buf + slen < last) ? slen : (size_t) (last - buf);
- buf = ((u_char *)memcpy (buf, p, len)) + len;
+ buf = ((gchar *)memcpy (buf, p, len)) + len;
}
fmt++;
continue;
case 'O':
- i64 = (int64_t) va_arg (args, off_t);
+ i64 = (gint64) va_arg (args, off_t);
sign = 1;
break;
case 'P':
- i64 = (int64_t) va_arg (args, pid_t);
+ i64 = (gint64) va_arg (args, pid_t);
sign = 1;
break;
case 'T':
- i64 = (int64_t) va_arg (args, time_t);
+ i64 = (gint64) va_arg (args, time_t);
sign = 1;
break;
case 'z':
if (sign) {
- i64 = (int64_t) va_arg (args, ssize_t);
+ i64 = (gint64) va_arg (args, ssize_t);
} else {
- ui64 = (uint64_t) va_arg (args, size_t);
+ ui64 = (guint64) va_arg (args, size_t);
}
break;
case 'd':
if (sign) {
- i64 = (int64_t) va_arg (args, int);
+ i64 = (gint64) va_arg (args, gint);
} else {
- ui64 = (uint64_t) va_arg (args, unsigned int);
+ ui64 = (guint64) va_arg (args, guint);
}
break;
case 'l':
if (sign) {
- i64 = (int64_t) va_arg(args, long);
+ i64 = (gint64) va_arg(args, long);
} else {
- ui64 = (uint64_t) va_arg(args, unsigned long);
+ ui64 = (guint64) va_arg(args, guint32);
}
break;
case 'D':
if (sign) {
- i64 = (int64_t) va_arg(args, int32_t);
+ i64 = (gint64) va_arg(args, gint32);
} else {
- ui64 = (uint64_t) va_arg(args, uint32_t);
+ ui64 = (guint64) va_arg(args, guint32);
}
break;
case 'L':
if (sign) {
- i64 = va_arg (args, int64_t);
+ i64 = va_arg (args, gint64);
} else {
- ui64 = va_arg (args, uint64_t);
+ ui64 = va_arg (args, guint64);
}
break;
f = -f;
}
- ui64 = (int64_t) f;
+ ui64 = (gint64) f;
buf = rspamd_sprintf_num (buf, last, ui64, zero, 0, width);
}
/*
- * (int64_t) cast is required for msvc6:
- * it can not convert uint64_t to double
+ * (gint64) cast is required for msvc6:
+ * it can not convert guint64 to double
*/
- ui64 = (uint64_t) ((f - (int64_t) ui64) * scale);
+ ui64 = (guint64) ((f - (gint64) ui64) * scale);
buf = rspamd_sprintf_num (buf, last, ui64, '0', 0, frac_width);
}
f = -f;
}
- ui64 = (int64_t) f;
+ ui64 = (gint64) f;
buf = rspamd_sprintf_num (buf, last, ui64, zero, 0, width);
}
/*
- * (int64_t) cast is required for msvc6:
- * it can not convert uint64_t to double
+ * (gint64) cast is required for msvc6:
+ * it can not convert guint64 to double
*/
- ui64 = (uint64_t) ((f - (int64_t) ui64) * scale);
+ ui64 = (guint64) ((f - (gint64) ui64) * scale);
buf = rspamd_sprintf_num (buf, last, ui64, '0', 0, frac_width);
}
break;
case 'c':
- d = va_arg (args, int);
- *buf++ = (u_char) (d & 0xff);
+ d = va_arg (args, gint);
+ *buf++ = (gchar) (d & 0xff);
fmt++;
continue;
if (sign) {
if (i64 < 0) {
*buf++ = '-';
- ui64 = (uint64_t) -i64;
+ ui64 = (guint64) -i64;
} else {
- ui64 = (uint64_t) i64;
+ ui64 = (guint64) i64;
}
}
}
-static u_char *
-rspamd_sprintf_num (u_char *buf, u_char *last, uint64_t ui64, u_char zero,
- unsigned int hexadecimal, unsigned int width)
+static gchar *
+rspamd_sprintf_num (gchar *buf, gchar *last, guint64 ui64, gchar zero,
+ guint hexadecimal, guint width)
{
- u_char *p, temp[sizeof ("18446744073709551615")];
+ gchar *p, temp[sizeof ("18446744073709551615")];
size_t len;
- uint32_t ui32;
- static u_char hex[] = "0123456789abcdef";
- static u_char HEX[] = "0123456789ABCDEF";
+ guint32 ui32;
+ static gchar hex[] = "0123456789abcdef";
+ static gchar HEX[] = "0123456789ABCDEF";
p = temp + sizeof(temp);
*
* For 32-bit numbers and some divisors gcc and icc use
* a inlined multiplication and shifts. For example,
- * unsigned "i32 / 10" is compiled to
+ * guint "i32 / 10" is compiled to
*
* (i32 * 0xCCCCCCCD) >> 35
*/
- ui32 = (uint32_t) ui64;
+ ui32 = (guint32) ui64;
do {
- *--p = (u_char) (ui32 % 10 + '0');
+ *--p = (gchar) (ui32 % 10 + '0');
} while (ui32 /= 10);
} else {
do {
- *--p = (u_char) (ui64 % 10 + '0');
+ *--p = (gchar) (ui64 % 10 + '0');
} while (ui64 /= 10);
}
do {
- /* the "(uint32_t)" cast disables the BCC's warning */
- *--p = hex[(uint32_t) (ui64 & 0xf)];
+ /* the "(guint32)" cast disables the BCC's warning */
+ *--p = hex[(guint32) (ui64 & 0xf)];
} while (ui64 >>= 4);
do {
- /* the "(uint32_t)" cast disables the BCC's warning */
- *--p = HEX[(uint32_t) (ui64 & 0xf)];
+ /* the "(guint32)" cast disables the BCC's warning */
+ *--p = HEX[(guint32) (ui64 & 0xf)];
} while (ui64 >>= 4);
}
len = last - buf;
}
- return ((u_char *)memcpy (buf, p, len)) + len;
+ return ((gchar *)memcpy (buf, p, len)) + len;
}
struct classifier_config;
/* Create socket and bind or connect it to specified address and port */
-int make_tcp_socket (struct in_addr *, u_short, gboolean is_server, gboolean async);
+gint make_tcp_socket (struct in_addr *, u_short, gboolean is_server, gboolean async);
/* Create socket and bind or connect it to specified address and port */
-int make_udp_socket (struct in_addr *, u_short, gboolean is_server, gboolean async);
+gint make_udp_socket (struct in_addr *, u_short, gboolean is_server, gboolean async);
/* Accept from socket */
-int accept_from_socket (int listen_sock, struct sockaddr *addr, socklen_t *len);
+gint accept_from_socket (gint listen_sock, struct sockaddr *addr, socklen_t *len);
/* Create and bind or connect unix socket */
-int make_unix_socket (const char *, struct sockaddr_un *, gboolean is_server);
+gint make_unix_socket (const gchar *, struct sockaddr_un *, gboolean is_server);
/* Write pid to file */
-int write_pid (struct rspamd_main *);
+gint write_pid (struct rspamd_main *);
/* Make specified socket non-blocking */
-int make_socket_nonblocking (int);
-int make_socket_blocking (int);
+gint make_socket_nonblocking (gint);
+gint make_socket_blocking (gint);
/* Poll sync socket for specified events */
-int poll_sync_socket (int fd, int timeout, short events);
+gint poll_sync_socket (gint fd, gint timeout, short events);
/* Init signals */
#ifdef HAVE_SA_SIGINFO
-void init_signals (struct sigaction *sa, void (*sig_handler)(int, siginfo_t *, void *));
+void init_signals (struct sigaction *sa, void (*sig_handler)(gint, siginfo_t *, void *));
#else
void init_signals (struct sigaction *sa, sighandler_t);
#endif
/* Send specified signal to each worker */
-void pass_signal_worker (GHashTable *, int );
+void pass_signal_worker (GHashTable *, gint );
/* Convert string to lowercase */
-void convert_to_lowercase (char *str, unsigned int size);
+void convert_to_lowercase (gchar *str, guint size);
#ifndef HAVE_SETPROCTITLE
-int init_title(int argc, char *argv[], char *envp[]);
-int setproctitle(const char *fmt, ...);
+gint init_title(gint argc, gchar *argv[], gchar *envp[]);
+gint setproctitle(const gchar *fmt, ...);
#endif
#ifndef HAVE_PIDFILE
struct pidfh {
- int pf_fd;
+ gint pf_fd;
#ifdef HAVE_PATH_MAX
- char pf_path[PATH_MAX + 1];
+ gchar pf_path[PATH_MAX + 1];
#elif defined(HAVE_MAXPATHLEN)
- char pf_path[MAXPATHLEN + 1];
+ gchar pf_path[MAXPATHLEN + 1];
#else
- char pf_path[1024 + 1];
+ gchar pf_path[1024 + 1];
#endif
dev_t pf_dev;
ino_t pf_ino;
};
-struct pidfh *pidfile_open(const char *path, mode_t mode, pid_t *pidptr);
-int pidfile_write(struct pidfh *pfh);
-int pidfile_close(struct pidfh *pfh);
-int pidfile_remove(struct pidfh *pfh);
+struct pidfh *pidfile_open(const gchar *path, mode_t mode, pid_t *pidptr);
+gint pidfile_write(struct pidfh *pfh);
+gint pidfile_close(struct pidfh *pfh);
+gint pidfile_remove(struct pidfh *pfh);
#endif
/* Replace %r with rcpt value and %f with from value, new string is allocated in pool */
-char* resolve_stat_filename (memory_pool_t *pool, char *pattern, char *rcpt, char *from);
+gchar* resolve_stat_filename (memory_pool_t *pool, gchar *pattern, gchar *rcpt, gchar *from);
#ifdef HAVE_CLOCK_GETTIME
-const char* calculate_check_time (struct timeval *tv, struct timespec *begin, int resolution);
+const gchar* calculate_check_time (struct timeval *tv, struct timespec *begin, gint resolution);
#else
-const char* calculate_check_time (struct timeval *begin, int resolution);
+const gchar* calculate_check_time (struct timeval *begin, gint resolution);
#endif
-double set_counter (const char *name, long int value);
+double set_counter (const gchar *name, guint32 value);
-gboolean lock_file (int fd, gboolean async);
-gboolean unlock_file (int fd, gboolean async);
+gboolean lock_file (gint fd, gboolean async);
+gboolean unlock_file (gint fd, gboolean async);
guint rspamd_strcase_hash (gconstpointer key);
gboolean rspamd_strcase_equal (gconstpointer v, gconstpointer v2);
guint fstr_strcase_hash (gconstpointer key);
gboolean fstr_strcase_equal (gconstpointer v, gconstpointer v2);
-void gperf_profiler_init (struct config_file *cfg, const char *descr);
+void gperf_profiler_init (struct config_file *cfg, const gchar *descr);
#ifdef RSPAMD_MAIN
stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct classifier_config *ccf,
- const char *symbol, struct statfile **st, gboolean try_create);
+ const gchar *symbol, struct statfile **st, gboolean try_create);
#endif
-int rspamd_sprintf (u_char *buf, const char *fmt, ...);
-int rspamd_snprintf (u_char *buf, size_t max, const char *fmt, ...);
-u_char *rspamd_vsnprintf (u_char *buf, size_t max, const char *fmt, va_list args);
+/*
+ * supported formats:
+ * %[0][width][x][X]O off_t
+ * %[0][width]T time_t
+ * %[0][width][u][x|X]z ssize_t/size_t
+ * %[0][width][u][x|X]d gint/guint
+ * %[0][width][u][x|X]l long
+ * %[0][width][u][x|X]D gint32/guint32
+ * %[0][width][u][x|X]L gint64/guint64
+ * %[0][width][.width]f double
+ * %[0][width][.width]F long double
+ * %[0][width][.width]g double
+ * %[0][width][.width]G long double
+ * %P pid_t
+ * %r rlim_t
+ * %p void *
+ * %V f_str_t *
+ * %s null-terminated string
+ * %*s length and string
+ * %Z '\0'
+ * %N '\n'
+ * %c gchar
+ * %% %
+ *
+ */
+gint rspamd_sprintf (gchar *buf, const gchar *fmt, ...);
+gint rspamd_fprintf (FILE *f, const gchar *fmt, ...);
+gint rspamd_snprintf (gchar *buf, size_t max, const gchar *fmt, ...);
+gchar *rspamd_vsnprintf (gchar *buf, size_t max, const gchar *fmt, va_list args);
#endif
}
gboolean
-add_view_from (struct rspamd_view * view, char *line)
+add_view_from (struct rspamd_view * view, gchar *line)
{
struct rspamd_regexp *re = NULL;
}
gboolean
-add_view_rcpt (struct rspamd_view * view, char *line)
+add_view_rcpt (struct rspamd_view * view, gchar *line)
{
struct rspamd_regexp *re = NULL;
}
gboolean
-add_view_symbols (struct rspamd_view * view, char *line)
+add_view_symbols (struct rspamd_view * view, gchar *line)
{
struct rspamd_regexp *re = NULL;
GList *symbols;
/* Try to parse symbols line as comma separated list */
symbols = parse_comma_list (view->pool, line);
while (symbols) {
- g_hash_table_insert (view->symbols_hash, (char *)symbols->data, symbols->data);
+ g_hash_table_insert (view->symbols_hash, (gchar *)symbols->data, symbols->data);
/* Symbols list would be free at pool destruction */
symbols = g_list_next (symbols);
}
}
gboolean
-add_view_ip (struct rspamd_view * view, char *line)
+add_view_ip (struct rspamd_view * view, gchar *line)
{
if (add_map (line, read_radix_list, fin_radix_list, (void **)&view->ip_tree)) {
return TRUE;
}
gboolean
-add_view_client_ip (struct rspamd_view * view, char *line)
+add_view_client_ip (struct rspamd_view * view, gchar *line)
{
if (add_map (line, read_radix_list, fin_radix_list, (void **)&view->client_ip_tree)) {
return TRUE;
check_view_rcpt (struct rspamd_view *v, struct worker_task *task)
{
GList *cur, *cur_re;
- char rcpt_user[256], *p;
+ gchar rcpt_user[256], *p;
gint l;
struct rspamd_regexp *re;
cur = task->rcpt;
while (cur) {
if ((p = strchr (cur->data, '@')) != NULL) {
- l = MIN (sizeof (rcpt_user) - 1, p - (char *)cur->data);
+ l = MIN (sizeof (rcpt_user) - 1, p - (gchar *)cur->data);
memcpy (rcpt_user, cur->data, l);
rcpt_user[l] = '\0';
/* First try to lookup in hashtable */
}
static gboolean
-match_view_symbol (struct rspamd_view *v, const char *symbol)
+match_view_symbol (struct rspamd_view *v, const gchar *symbol)
{
GList *cur;
struct rspamd_regexp *re;
}
gboolean
-check_view (GList * views, const char *symbol, struct worker_task * task)
+check_view (GList * views, const gchar *symbol, struct worker_task * task)
{
struct rspamd_view *selected = NULL;
struct rspamd_view* init_view (memory_pool_t *pool);
-gboolean add_view_from (struct rspamd_view *view, char *line);
-gboolean add_view_rcpt (struct rspamd_view *view, char *line);
-gboolean add_view_ip (struct rspamd_view *view, char *line);
-gboolean add_view_client_ip (struct rspamd_view *view, char *line);
-gboolean add_view_symbols (struct rspamd_view *view, char *line);
+gboolean add_view_from (struct rspamd_view *view, gchar *line);
+gboolean add_view_rcpt (struct rspamd_view *view, gchar *line);
+gboolean add_view_ip (struct rspamd_view *view, gchar *line);
+gboolean add_view_client_ip (struct rspamd_view *view, gchar *line);
+gboolean add_view_symbols (struct rspamd_view *view, gchar *line);
-gboolean check_view (GList *views, const char *symbol, struct worker_task *task);
+gboolean check_view (GList *views, const gchar *symbol, struct worker_task *task);
gboolean check_skip (GList *views, struct worker_task *task);
#endif
#include "lua/lua_common.h"
#ifndef WITHOUT_PERL
-# include <EXTERN.h> /* from the Perl distribution */
-# include <perl.h> /* from the Perl distribution */
+# include <EXTERN.h> /* from the Perl distribution */
+# include <perl.h> /* from the Perl distribution */
extern PerlInterpreter *perl_interpreter;
#endif
#define MODULE_AFTER_CONNECT_FUNC "after_connect"
#define MODULE_PARSE_LINE_FUNC "parse_line"
-struct custom_filter {
- char *filename; /*< filename */
- GModule *handle; /*< returned by dlopen */
- void (*init_func)(struct config_file *cfg); /*< called at start of worker */
- void* (*before_connect)(void); /*< called when clients connects */
- gboolean (*process_line)(const char *line, size_t len, char **output, void *user_data); /*< called when client send data line */
- void (*after_connect)(char **output, char **log_line, void *user_data); /*< called when client disconnects */
- void (*fin_func)(void);
+struct custom_filter
+{
+ gchar *filename; /*< filename */
+ GModule *handle; /*< returned by dlopen */
+ void (*init_func) (struct config_file * cfg); /*< called at start of worker */
+ void *(*before_connect) (void); /*< called when clients connects */
+ gboolean (*process_line) (const gchar * line, size_t len, gchar ** output, void *user_data); /*< called when client send data line */
+ void (*after_connect) (gchar ** output, gchar ** log_line, void *user_data); /*< called when client disconnects */
+ void (*fin_func) (void);
};
#endif
/*
* Worker's context
*/
-struct rspamd_worker_ctx {
- struct timeval io_tv;
- /* Detect whether this worker is mime worker */
- gboolean is_mime;
- /* Detect whether this worker is mime worker */
- gboolean is_custom;
- GList *custom_filters;
- /* DNS resolver */
- struct rspamd_dns_resolver *resolver;
+struct rspamd_worker_ctx
+{
+ struct timeval io_tv;
+ /* Detect whether this worker is mime worker */
+ gboolean is_mime;
+ /* Detect whether this worker is mime worker */
+ gboolean is_custom;
+ GList *custom_filters;
+ /* DNS resolver */
+ struct rspamd_dns_resolver *resolver;
};
static gboolean write_socket (void *arg);
-static sig_atomic_t wanna_die = 0;
+static sig_atomic_t wanna_die = 0;
#ifndef HAVE_SA_SIGINFO
static void
-sig_handler (int signo)
+sig_handler (gint signo)
#else
static void
-sig_handler (int signo, siginfo_t *info, void *unused)
+sig_handler (gint signo, siginfo_t * info, void *unused)
#endif
{
- struct timeval tv;
-
- switch (signo) {
- case SIGUSR1:
- reopen_log ();
- break;
- case SIGINT:
- case SIGTERM:
- if (!wanna_die) {
- wanna_die = 1;
- tv.tv_sec = 0;
- tv.tv_usec = 0;
- event_loopexit (&tv);
+ struct timeval tv;
+
+ switch (signo)
+ {
+ case SIGUSR1:
+ reopen_log ();
+ break;
+ case SIGINT:
+ case SIGTERM:
+ if (!wanna_die)
+ {
+ wanna_die = 1;
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ event_loopexit (&tv);
#ifdef WITH_GPERF_TOOLS
- ProfilerStop ();
+ ProfilerStop ();
#endif
- }
- break;
}
+ break;
+ }
}
/*
* Config reload is designed by sending sigusr to active workers and pending shutdown of them
*/
static void
-sigusr_handler (int fd, short what, void *arg)
+sigusr_handler (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- /* Do not accept new connections, preparing to end worker's process */
- struct timeval tv;
- if (! wanna_die) {
- tv.tv_sec = SOFT_SHUTDOWN_TIME;
- tv.tv_usec = 0;
- event_del (&worker->sig_ev);
- event_del (&worker->bind_ev);
- do_reopen_log = 1;
- msg_info ("worker's shutdown is pending in %d sec", SOFT_SHUTDOWN_TIME);
- event_loopexit (&tv);
- }
- return;
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ /* Do not accept new connections, preparing to end worker's process */
+ struct timeval tv;
+ if (!wanna_die)
+ {
+ tv.tv_sec = SOFT_SHUTDOWN_TIME;
+ tv.tv_usec = 0;
+ event_del (&worker->sig_ev);
+ event_del (&worker->bind_ev);
+ do_reopen_log = 1;
+ msg_info ("worker's shutdown is pending in %d sec", SOFT_SHUTDOWN_TIME);
+ event_loopexit (&tv);
+ }
+ return;
}
/*
static void
rcpt_destruct (void *pointer)
{
- struct worker_task *task = (struct worker_task *)pointer;
+ struct worker_task *task = (struct worker_task *) pointer;
- if (task->rcpt) {
- g_list_free (task->rcpt);
- }
+ if (task->rcpt)
+ {
+ g_list_free (task->rcpt);
+ }
}
-#ifndef BUILD_STATIC
+#ifndef BUILD_STATIC
static void
fin_custom_filters (struct worker_task *task)
{
- GList *cur, *curd;
- struct custom_filter *filt;
- char *output = NULL, *log = NULL;
- struct rspamd_worker_ctx *ctx = task->worker->ctx;
-
- cur = ctx->custom_filters;
- curd = task->rcpt;
- while (cur) {
- filt = cur->data;
- if (filt->after_connect) {
- filt->after_connect (&output, &log, curd->data);
- if (output != NULL) {
- if (! rspamd_dispatcher_write (task->dispatcher, output, strlen (output), FALSE, FALSE)) {
- g_free (output);
- return;
- }
- g_free (output);
- }
- if (log != NULL) {
- msg_info ("%s", log);
- g_free (log);
- }
- if (curd->next) {
- curd = g_list_next (curd);
- }
+ GList *cur, *curd;
+ struct custom_filter *filt;
+ gchar *output = NULL, *log = NULL;
+ struct rspamd_worker_ctx *ctx = task->worker->ctx;
+
+ cur = ctx->custom_filters;
+ curd = task->rcpt;
+ while (cur)
+ {
+ filt = cur->data;
+ if (filt->after_connect)
+ {
+ filt->after_connect (&output, &log, curd->data);
+ if (output != NULL)
+ {
+ if (!rspamd_dispatcher_write
+ (task->dispatcher, output, strlen (output), FALSE, FALSE))
+ {
+ g_free (output);
+ return;
}
- cur = g_list_next (cur);
+ g_free (output);
+ }
+ if (log != NULL)
+ {
+ msg_info ("%s", log);
+ g_free (log);
+ }
+ if (curd->next)
+ {
+ curd = g_list_next (curd);
+ }
}
+ cur = g_list_next (cur);
+ }
}
-static gboolean
-parse_line_custom (struct worker_task *task, f_str_t *in)
+static gboolean
+parse_line_custom (struct worker_task *task, f_str_t * in)
{
- GList *cur, *curd;
- struct custom_filter *filt;
- char *output = NULL;
- gboolean res = TRUE;
- struct rspamd_worker_ctx *ctx = task->worker->ctx;
-
- cur = ctx->custom_filters;
- curd = task->rcpt;
- while (cur) {
- filt = cur->data;
- if (filt->after_connect) {
- if (! filt->process_line (in->begin, in->len, &output, curd->data)) {
- res = FALSE;
- }
- if (output != NULL) {
- if (! rspamd_dispatcher_write (task->dispatcher, output, strlen (output), FALSE, FALSE)) {
- g_free (output);
- return FALSE;
- }
- g_free (output);
- }
- if (curd->next) {
- curd = g_list_next (curd);
- }
+ GList *cur, *curd;
+ struct custom_filter *filt;
+ gchar *output = NULL;
+ gboolean res = TRUE;
+ struct rspamd_worker_ctx *ctx = task->worker->ctx;
+
+ cur = ctx->custom_filters;
+ curd = task->rcpt;
+ while (cur)
+ {
+ filt = cur->data;
+ if (filt->after_connect)
+ {
+ if (!filt->process_line (in->begin, in->len, &output, curd->data))
+ {
+ res = FALSE;
+ }
+ if (output != NULL)
+ {
+ if (!rspamd_dispatcher_write
+ (task->dispatcher, output, strlen (output), FALSE, FALSE))
+ {
+ g_free (output);
+ return FALSE;
}
- cur = g_list_next (cur);
+ g_free (output);
+ }
+ if (curd->next)
+ {
+ curd = g_list_next (curd);
+ }
}
+ cur = g_list_next (cur);
+ }
- return res;
+ return res;
}
#else
/* Stubs */
{
}
-static gboolean
-parse_line_custom (struct worker_task *task, f_str_t *in)
+
+static gboolean
+parse_line_custom (struct worker_task *task, f_str_t * in)
{
- return FALSE;
+ return FALSE;
}
#endif
void
free_task (struct worker_task *task, gboolean is_soft)
{
- GList *part;
- struct mime_part *p;
-
- if (task) {
- debug_task ("free pointer %p", task);
- while ((part = g_list_first (task->parts))) {
- task->parts = g_list_remove_link (task->parts, part);
- p = (struct mime_part *)part->data;
- g_byte_array_free (p->content, TRUE);
- g_list_free_1 (part);
- }
- if (task->text_parts) {
- g_list_free (task->text_parts);
- }
- if (task->urls) {
- g_list_free (task->urls);
- }
- if (task->images) {
- g_list_free (task->images);
- }
- if (task->messages) {
- g_list_free (task->messages);
- }
- memory_pool_delete (task->task_pool);
- if (task->dispatcher) {
- if (is_soft) {
- /* Plan dispatcher shutdown */
- task->dispatcher->wanna_die = 1;
- }
- else {
- rspamd_remove_dispatcher (task->dispatcher);
- }
- }
- if (task->sock != -1) {
- close (task->sock);
- }
- g_free (task);
+ GList *part;
+ struct mime_part *p;
+
+ if (task)
+ {
+ debug_task ("free pointer %p", task);
+ while ((part = g_list_first (task->parts)))
+ {
+ task->parts = g_list_remove_link (task->parts, part);
+ p = (struct mime_part *) part->data;
+ g_byte_array_free (p->content, TRUE);
+ g_list_free_1 (part);
+ }
+ if (task->text_parts)
+ {
+ g_list_free (task->text_parts);
+ }
+ if (task->urls)
+ {
+ g_list_free (task->urls);
+ }
+ if (task->images)
+ {
+ g_list_free (task->images);
+ }
+ if (task->messages)
+ {
+ g_list_free (task->messages);
+ }
+ memory_pool_delete (task->task_pool);
+ if (task->dispatcher)
+ {
+ if (is_soft)
+ {
+ /* Plan dispatcher shutdown */
+ task->dispatcher->wanna_die = 1;
+ }
+ else
+ {
+ rspamd_remove_dispatcher (task->dispatcher);
+ }
+ }
+ if (task->sock != -1)
+ {
+ close (task->sock);
}
+ g_free (task);
+ }
}
void
free_task_hard (gpointer ud)
{
- struct worker_task *task = ud;
+ struct worker_task *task = ud;
- free_task (task, FALSE);
+ free_task (task, FALSE);
}
void
free_task_soft (gpointer ud)
{
- struct worker_task *task = ud;
+ struct worker_task *task = ud;
- free_task (task, FALSE);
+ free_task (task, FALSE);
}
/*
static gboolean
read_socket (f_str_t * in, void *arg)
{
- struct worker_task *task = (struct worker_task *)arg;
- struct rspamd_worker_ctx *ctx;
- ssize_t r;
-
- ctx = task->worker->ctx;
- switch (task->state) {
- case READ_COMMAND:
- case READ_HEADER:
- if (ctx->is_custom) {
- if (! parse_line_custom (task, in)) {
- task->last_error = "Read error";
- task->error_code = RSPAMD_NETWORK_ERROR;
- task->state = WRITE_ERROR;
- }
- }
- else {
- if (read_rspamd_input_line (task, in) != 0) {
- task->last_error = "Read error";
- task->error_code = RSPAMD_NETWORK_ERROR;
- task->state = WRITE_ERROR;
- }
- }
- if (task->state == WRITE_REPLY || task->state == WRITE_ERROR) {
- return write_socket (task);
- }
- break;
- case READ_MESSAGE:
- task->msg = memory_pool_alloc (task->task_pool, sizeof (f_str_t));
- task->msg->begin = in->begin;
- task->msg->len = in->len;
- debug_task ("got string of length %ld", (long int)task->msg->len);
- r = process_message (task);
- if (r == -1) {
- msg_warn ("processing of message failed");
- task->last_error = "MIME processing error";
- task->error_code = RSPAMD_FILTER_ERROR;
- task->state = WRITE_ERROR;
- return write_socket (task);
- }
- if (task->cmd == CMD_OTHER) {
- /* Skip filters */
- task->state = WRITE_REPLY;
- return write_socket (task);
- }
- r = process_filters (task);
- if (r == -1) {
- task->last_error = "Filter processing error";
- task->error_code = RSPAMD_FILTER_ERROR;
- task->state = WRITE_ERROR;
- return write_socket (task);
- }
- else if (r == 0) {
- task->state = WAIT_FILTER;
- rspamd_dispatcher_pause (task->dispatcher);
- }
- else {
- process_statfiles (task);
- lua_call_post_filters (task);
- task->state = WRITE_REPLY;
- return write_socket (task);
- }
- break;
- case WRITE_REPLY:
- case WRITE_ERROR:
- return write_socket (task);
- break;
- default:
- debug_task ("invalid state on reading stage");
- break;
+ struct worker_task *task = (struct worker_task *) arg;
+ struct rspamd_worker_ctx *ctx;
+ ssize_t r;
+
+ ctx = task->worker->ctx;
+ switch (task->state)
+ {
+ case READ_COMMAND:
+ case READ_HEADER:
+ if (ctx->is_custom)
+ {
+ if (!parse_line_custom (task, in))
+ {
+ task->last_error = "Read error";
+ task->error_code = RSPAMD_NETWORK_ERROR;
+ task->state = WRITE_ERROR;
+ }
}
-
- return TRUE;
+ else
+ {
+ if (read_rspamd_input_line (task, in) != 0)
+ {
+ task->last_error = "Read error";
+ task->error_code = RSPAMD_NETWORK_ERROR;
+ task->state = WRITE_ERROR;
+ }
+ }
+ if (task->state == WRITE_REPLY || task->state == WRITE_ERROR)
+ {
+ return write_socket (task);
+ }
+ break;
+ case READ_MESSAGE:
+ task->msg = memory_pool_alloc (task->task_pool, sizeof (f_str_t));
+ task->msg->begin = in->begin;
+ task->msg->len = in->len;
+ debug_task ("got string of length %z", task->msg->len);
+ r = process_message (task);
+ if (r == -1)
+ {
+ msg_warn ("processing of message failed");
+ task->last_error = "MIME processing error";
+ task->error_code = RSPAMD_FILTER_ERROR;
+ task->state = WRITE_ERROR;
+ return write_socket (task);
+ }
+ if (task->cmd == CMD_OTHER)
+ {
+ /* Skip filters */
+ task->state = WRITE_REPLY;
+ return write_socket (task);
+ }
+ r = process_filters (task);
+ if (r == -1)
+ {
+ task->last_error = "Filter processing error";
+ task->error_code = RSPAMD_FILTER_ERROR;
+ task->state = WRITE_ERROR;
+ return write_socket (task);
+ }
+ else if (r == 0)
+ {
+ task->state = WAIT_FILTER;
+ rspamd_dispatcher_pause (task->dispatcher);
+ }
+ else
+ {
+ process_statfiles (task);
+ lua_call_post_filters (task);
+ task->state = WRITE_REPLY;
+ return write_socket (task);
+ }
+ break;
+ case WRITE_REPLY:
+ case WRITE_ERROR:
+ return write_socket (task);
+ break;
+ default:
+ debug_task ("invalid state on reading stage");
+ break;
+ }
+
+ return TRUE;
}
/*
static gboolean
write_socket (void *arg)
{
- struct worker_task *task = (struct worker_task *)arg;
- struct rspamd_worker_ctx *ctx;
-
- ctx = task->worker->ctx;
-
- switch (task->state) {
- case WRITE_REPLY:
- if (! write_reply (task)) {
- destroy_session (task->s);
- return FALSE;
- }
- if (ctx->is_custom) {
- fin_custom_filters (task);
- }
- destroy_session (task->s);
- return FALSE;
- break;
- case WRITE_ERROR:
- if (! write_reply (task)) {
- return FALSE;
- }
- if (ctx->is_custom) {
- fin_custom_filters (task);
- }
- destroy_session (task->s);
- return FALSE;
- break;
- case CLOSING_CONNECTION:
- debug_task ("normally closing connection");
- if (ctx->is_custom) {
- fin_custom_filters (task);
- }
- destroy_session (task->s);
- return FALSE;
- break;
- default:
- msg_info ("abnormally closing connection");
- if (ctx->is_custom) {
- fin_custom_filters (task);
- }
- destroy_session (task->s);
- return FALSE;
- break;
+ struct worker_task *task = (struct worker_task *) arg;
+ struct rspamd_worker_ctx *ctx;
+
+ ctx = task->worker->ctx;
+
+ switch (task->state)
+ {
+ case WRITE_REPLY:
+ if (!write_reply (task))
+ {
+ destroy_session (task->s);
+ return FALSE;
+ }
+ if (ctx->is_custom)
+ {
+ fin_custom_filters (task);
+ }
+ destroy_session (task->s);
+ return FALSE;
+ break;
+ case WRITE_ERROR:
+ if (!write_reply (task))
+ {
+ return FALSE;
+ }
+ if (ctx->is_custom)
+ {
+ fin_custom_filters (task);
}
- return TRUE;
+ destroy_session (task->s);
+ return FALSE;
+ break;
+ case CLOSING_CONNECTION:
+ debug_task ("normally closing connection");
+ if (ctx->is_custom)
+ {
+ fin_custom_filters (task);
+ }
+ destroy_session (task->s);
+ return FALSE;
+ break;
+ default:
+ msg_info ("abnormally closing connection");
+ if (ctx->is_custom)
+ {
+ fin_custom_filters (task);
+ }
+ destroy_session (task->s);
+ return FALSE;
+ break;
+ }
+ return TRUE;
}
/*
static void
err_socket (GError * err, void *arg)
{
- struct worker_task *task = (struct worker_task *)arg;
- struct rspamd_worker_ctx *ctx;
-
- ctx = task->worker->ctx;
- msg_info ("abnormally closing connection, error: %s", err->message);
- /* Free buffers */
- if (ctx->is_custom) {
- fin_custom_filters (task);
- }
- if (task->state != WRITE_REPLY) {
- destroy_session (task->s);
- }
+ struct worker_task *task = (struct worker_task *) arg;
+ struct rspamd_worker_ctx *ctx;
+
+ ctx = task->worker->ctx;
+ msg_info ("abnormally closing connection, error: %s", err->message);
+ /* Free buffers */
+ if (ctx->is_custom)
+ {
+ fin_custom_filters (task);
+ }
+ if (task->state != WRITE_REPLY)
+ {
+ destroy_session (task->s);
+ }
}
struct worker_task *
construct_task (struct rspamd_worker *worker)
{
- struct worker_task *new_task;
+ struct worker_task *new_task;
- new_task = g_malloc (sizeof (struct worker_task));
+ new_task = g_malloc (sizeof (struct worker_task));
- bzero (new_task, sizeof (struct worker_task));
- new_task->worker = worker;
- new_task->state = READ_COMMAND;
- new_task->cfg = worker->srv->cfg;
- new_task->from_addr.s_addr = INADDR_NONE;
- new_task->view_checked = FALSE;
+ bzero (new_task, sizeof (struct worker_task));
+ new_task->worker = worker;
+ new_task->state = READ_COMMAND;
+ new_task->cfg = worker->srv->cfg;
+ new_task->from_addr.s_addr = INADDR_NONE;
+ new_task->view_checked = FALSE;
#ifdef HAVE_CLOCK_GETTIME
# ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
- clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &new_task->ts);
+ 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) {
- msg_warn ("gettimeofday failed: %s", strerror (errno));
- }
-
- new_task->task_pool = memory_pool_new (memory_pool_get_size ());
-
- /* Add destructor for recipients list (it would be better to use anonymous function here */
- memory_pool_add_destructor (new_task->task_pool, (pool_destruct_func) rcpt_destruct, new_task);
- new_task->results = g_hash_table_new (g_str_hash, g_str_equal);
- memory_pool_add_destructor (new_task->task_pool, (pool_destruct_func) g_hash_table_destroy, new_task->results);
- new_task->re_cache = g_hash_table_new (g_str_hash, g_str_equal);
- memory_pool_add_destructor (new_task->task_pool, (pool_destruct_func) g_hash_table_destroy, new_task->re_cache);
- new_task->s = new_async_session (new_task->task_pool, free_task_hard, new_task);
- new_task->sock = -1;
- new_task->is_mime = TRUE;
-
- return new_task;
+ if (gettimeofday (&new_task->tv, NULL) == -1)
+ {
+ msg_warn ("gettimeofday failed: %s", strerror (errno));
+ }
+
+ new_task->task_pool = memory_pool_new (memory_pool_get_size ());
+
+ /* Add destructor for recipients list (it would be better to use anonymous function here */
+ memory_pool_add_destructor (new_task->task_pool,
+ (pool_destruct_func) rcpt_destruct, new_task);
+ new_task->results = g_hash_table_new (g_str_hash, g_str_equal);
+ memory_pool_add_destructor (new_task->task_pool,
+ (pool_destruct_func) g_hash_table_destroy,
+ new_task->results);
+ new_task->re_cache = g_hash_table_new (g_str_hash, g_str_equal);
+ memory_pool_add_destructor (new_task->task_pool,
+ (pool_destruct_func) g_hash_table_destroy,
+ new_task->re_cache);
+ new_task->s =
+ new_async_session (new_task->task_pool, free_task_hard, new_task);
+ new_task->sock = -1;
+ new_task->is_mime = TRUE;
+
+ return new_task;
}
/*
* Accept new connection and construct task
*/
static void
-accept_socket (int fd, short what, void *arg)
+accept_socket (gint fd, short what, void *arg)
{
- struct rspamd_worker *worker = (struct rspamd_worker *)arg;
- struct rspamd_worker_ctx *ctx;
- union sa_union su;
- struct worker_task *new_task;
- GList *cur;
- struct custom_filter *filt;
-
- socklen_t addrlen = sizeof (su.ss);
- int nfd;
-
- ctx = worker->ctx;
- if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
- msg_warn ("accept failed: %s", strerror (errno));
- return;
- }
- /* Check for EAGAIN */
- if (nfd == 0) {
- return;
- }
-
- new_task = construct_task (worker);
-
- if (su.ss.ss_family == AF_UNIX) {
- msg_info ("accepted connection from unix socket");
- 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));
- }
-
- new_task->sock = nfd;
- new_task->is_mime = ctx->is_mime;
- worker->srv->stat->connections_count++;
- new_task->resolver = ctx->resolver;
- ctx->io_tv.tv_sec = WORKER_IO_TIMEOUT;
- ctx->io_tv.tv_usec = 0;
-
- /* Set up dispatcher */
- new_task->dispatcher = rspamd_create_dispatcher (nfd, BUFFER_LINE, read_socket, write_socket, err_socket, &ctx->io_tv, (void *)new_task);
- new_task->dispatcher->peer_addr = new_task->client_addr.s_addr;
-
- /* Init custom filters */
-#ifndef BUILD_STATIC
- if (ctx->is_custom) {
- cur = ctx->custom_filters;
- while (cur) {
- filt = cur->data;
- if (filt->before_connect) {
- /* XXX: maybe not use rcpt list here for custom filters data, but this can save some bytes in task structure */
- new_task->rcpt = g_list_prepend (new_task->rcpt, filt->before_connect ());
- }
- cur = g_list_next (cur);
- }
- /* Keep user data in the same order as custom filters */
- new_task->rcpt = g_list_reverse (new_task->rcpt);
+ struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+ struct rspamd_worker_ctx *ctx;
+ union sa_union su;
+ struct worker_task *new_task;
+ GList *cur;
+ struct custom_filter *filt;
+
+ socklen_t addrlen = sizeof (su.ss);
+ gint nfd;
+
+ ctx = worker->ctx;
+ if ((nfd =
+ accept_from_socket (fd, (struct sockaddr *) &su.ss, &addrlen)) == -1)
+ {
+ msg_warn ("accept failed: %s", strerror (errno));
+ return;
+ }
+ /* Check for EAGAIN */
+ if (nfd == 0)
+ {
+ return;
+ }
+
+ new_task = construct_task (worker);
+
+ if (su.ss.ss_family == AF_UNIX)
+ {
+ msg_info ("accepted connection from unix socket");
+ 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));
+ }
+
+ new_task->sock = nfd;
+ new_task->is_mime = ctx->is_mime;
+ worker->srv->stat->connections_count++;
+ new_task->resolver = ctx->resolver;
+ ctx->io_tv.tv_sec = WORKER_IO_TIMEOUT;
+ ctx->io_tv.tv_usec = 0;
+
+ /* Set up dispatcher */
+ new_task->dispatcher =
+ rspamd_create_dispatcher (nfd, BUFFER_LINE, read_socket, write_socket,
+ err_socket, &ctx->io_tv, (void *) new_task);
+ new_task->dispatcher->peer_addr = new_task->client_addr.s_addr;
+
+ /* Init custom filters */
+#ifndef BUILD_STATIC
+ if (ctx->is_custom)
+ {
+ cur = ctx->custom_filters;
+ while (cur)
+ {
+ filt = cur->data;
+ if (filt->before_connect)
+ {
+ /* XXX: maybe not use rcpt list here for custom filters data, but this can save some bytes in task structure */
+ new_task->rcpt =
+ g_list_prepend (new_task->rcpt, filt->before_connect ());
+ }
+ cur = g_list_next (cur);
}
+ /* Keep user data in the same order as custom filters */
+ new_task->rcpt = g_list_reverse (new_task->rcpt);
+ }
#endif
}
#ifndef BUILD_STATIC
-static gboolean
-load_custom_filter (struct config_file *cfg, const char *file, struct rspamd_worker_ctx *ctx)
+static gboolean
+load_custom_filter (struct config_file *cfg, const gchar * file,
+ struct rspamd_worker_ctx *ctx)
{
- struct custom_filter *filt;
- struct stat st;
-
- if (stat (file, &st) == -1 || !S_ISREG (st.st_mode)) {
- msg_info ("stat failed for %s", file);
- return FALSE;
- }
-
- filt = g_malloc (sizeof (struct custom_filter));
-
- filt->handle = g_module_open (file, G_MODULE_BIND_LAZY);
- if (!filt->handle) {
- msg_info ("module load failed: %s", g_module_error ());
- g_free (filt);
- return FALSE;
- }
-
- /* Now extract functions from custom module */
- if (!g_module_symbol (filt->handle, MODULE_INIT_FUNC, (gpointer *)&filt->init_func) ||
- !g_module_symbol (filt->handle, MODULE_FINIT_FUNC, (gpointer *)&filt->fin_func) ||
- !g_module_symbol (filt->handle, MODULE_BEFORE_CONNECT_FUNC, (gpointer *)&filt->before_connect) ||
- !g_module_symbol (filt->handle, MODULE_AFTER_CONNECT_FUNC, (gpointer *)&filt->after_connect) ||
- !g_module_symbol (filt->handle, MODULE_PARSE_LINE_FUNC, (gpointer *)&filt->process_line)) {
-
- msg_info ("cannot find handlers in module %s: %s", file, g_module_error ());
- g_free (filt);
- return FALSE;
- }
-
- filt->init_func (cfg);
- filt->filename = g_strdup (file);
- ctx->custom_filters = g_list_prepend (ctx->custom_filters, filt);
-
- return TRUE;
+ struct custom_filter *filt;
+ struct stat st;
+
+ if (stat (file, &st) == -1 || !S_ISREG (st.st_mode))
+ {
+ msg_info ("stat failed for %s", file);
+ return FALSE;
+ }
+
+ filt = g_malloc (sizeof (struct custom_filter));
+
+ filt->handle = g_module_open (file, G_MODULE_BIND_LAZY);
+ if (!filt->handle)
+ {
+ msg_info ("module load failed: %s", g_module_error ());
+ g_free (filt);
+ return FALSE;
+ }
+
+ /* Now extract functions from custom module */
+ if (!g_module_symbol
+ (filt->handle, MODULE_INIT_FUNC, (gpointer *) & filt->init_func)
+ || !g_module_symbol (filt->handle, MODULE_FINIT_FUNC,
+ (gpointer *) & filt->fin_func)
+ || !g_module_symbol (filt->handle, MODULE_BEFORE_CONNECT_FUNC,
+ (gpointer *) & filt->before_connect)
+ || !g_module_symbol (filt->handle, MODULE_AFTER_CONNECT_FUNC,
+ (gpointer *) & filt->after_connect)
+ || !g_module_symbol (filt->handle, MODULE_PARSE_LINE_FUNC,
+ (gpointer *) & filt->process_line))
+ {
+
+ msg_info ("cannot find handlers in module %s: %s", file,
+ g_module_error ());
+ g_free (filt);
+ return FALSE;
+ }
+
+ filt->init_func (cfg);
+ filt->filename = g_strdup (file);
+ ctx->custom_filters = g_list_prepend (ctx->custom_filters, filt);
+
+ return TRUE;
}
/*
* Load custom filters from specified path
*/
-static gboolean
-load_custom_filters (struct rspamd_worker *worker, const char *path)
+static gboolean
+load_custom_filters (struct rspamd_worker *worker, const gchar * path)
{
- glob_t gp;
- int r, i;
- struct rspamd_worker_ctx *ctx = worker->ctx;
-
- gp.gl_offs = 0;
- if ((r = glob (path, GLOB_NOSORT, NULL, &gp)) != 0) {
- msg_warn ("glob failed: %s, %d", strerror (errno), r);
- return FALSE;
- }
-
- for (i = 0; i < gp.gl_pathc; i ++) {
- if (! load_custom_filter (worker->srv->cfg, gp.gl_pathv[i], ctx)) {
- globfree (&gp);
- return FALSE;
- }
+ glob_t gp;
+ gint r, i;
+ struct rspamd_worker_ctx *ctx = worker->ctx;
+
+ gp.gl_offs = 0;
+ if ((r = glob (path, GLOB_NOSORT, NULL, &gp)) != 0)
+ {
+ msg_warn ("glob failed: %s, %d", strerror (errno), r);
+ return FALSE;
+ }
+
+ for (i = 0; i < gp.gl_pathc; i++)
+ {
+ if (!load_custom_filter (worker->srv->cfg, gp.gl_pathv[i], ctx))
+ {
+ globfree (&gp);
+ return FALSE;
}
+ }
- globfree (&gp);
+ globfree (&gp);
- return TRUE;
+ return TRUE;
}
static void
unload_custom_filters (struct rspamd_worker_ctx *ctx)
{
- GList *cur;
- struct custom_filter *filt;
-
- cur = ctx->custom_filters;
- while (cur) {
- filt = cur->data;
- if (filt->fin_func) {
- filt->fin_func ();
- }
- g_module_close (filt->handle);
- g_free (filt);
- cur = g_list_next (cur);
+ GList *cur;
+ struct custom_filter *filt;
+
+ cur = ctx->custom_filters;
+ while (cur)
+ {
+ filt = cur->data;
+ if (filt->fin_func)
+ {
+ filt->fin_func ();
}
+ g_module_close (filt->handle);
+ g_free (filt);
+ cur = g_list_next (cur);
+ }
- g_list_free (ctx->custom_filters);
+ g_list_free (ctx->custom_filters);
}
#endif
void
start_worker (struct rspamd_worker *worker)
{
- struct sigaction signals;
- char *is_mime_str;
- char *is_custom_str;
- struct rspamd_worker_ctx *ctx;
+ struct sigaction signals;
+ gchar *is_mime_str;
+ gchar *is_custom_str;
+ struct rspamd_worker_ctx *ctx;
#ifdef WITH_PROFILER
- extern void _start (void), etext (void);
- monstartup ((u_long) & _start, (u_long) & etext);
+ extern void _start (void), etext (void);
+ monstartup ((u_long) & _start, (u_long) & etext);
#endif
- gperf_profiler_init (worker->srv->cfg, "worker");
+ gperf_profiler_init (worker->srv->cfg, "worker");
- worker->srv->pid = getpid ();
+ worker->srv->pid = getpid ();
- event_init ();
+ event_init ();
- init_signals (&signals, sig_handler);
- sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
+ init_signals (&signals, sig_handler);
+ sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
- /* SIGUSR2 handler */
- signal_set (&worker->sig_ev, SIGUSR2, sigusr_handler, (void *)worker);
- signal_add (&worker->sig_ev, NULL);
+ /* SIGUSR2 handler */
+ signal_set (&worker->sig_ev, SIGUSR2, sigusr_handler, (void *) worker);
+ signal_add (&worker->sig_ev, NULL);
- /* Accept event */
- event_set (&worker->bind_ev, worker->cf->listen_sock, EV_READ | EV_PERSIST, accept_socket, (void *)worker);
- event_add (&worker->bind_ev, NULL);
+ /* Accept event */
+ event_set (&worker->bind_ev, worker->cf->listen_sock, EV_READ | EV_PERSIST,
+ accept_socket, (void *) worker);
+ event_add (&worker->bind_ev, NULL);
- /* Fill ctx */
- ctx = g_malloc0 (sizeof (struct rspamd_worker_ctx));
- worker->ctx = ctx;
+ /* Fill ctx */
+ ctx = g_malloc0 (sizeof (struct rspamd_worker_ctx));
+ worker->ctx = ctx;
-#ifndef BUILD_STATIC
- /* Check if this worker is not usual rspamd worker, but uses custom filters from specified path */
- is_custom_str = g_hash_table_lookup (worker->cf->params, "custom_filters");
- if (is_custom_str && g_module_supported () && load_custom_filters (worker, is_custom_str)) {
- msg_info ("starting custom process, loaded modules from %s", is_custom_str);
- ctx->is_custom = TRUE;
- }
- else {
+#ifndef BUILD_STATIC
+ /* Check if this worker is not usual rspamd worker, but uses custom filters from specified path */
+ is_custom_str = g_hash_table_lookup (worker->cf->params, "custom_filters");
+ if (is_custom_str && g_module_supported ()
+ && load_custom_filters (worker, is_custom_str))
+ {
+ msg_info ("starting custom process, loaded modules from %s",
+ is_custom_str);
+ ctx->is_custom = TRUE;
+ }
+ else
+ {
#endif
- /* Maps events */
- start_map_watch ();
- /* Check whether we are mime worker */
- is_mime_str = g_hash_table_lookup (worker->cf->params, "mime");
- if (is_mime_str != NULL && (g_ascii_strcasecmp (is_mime_str, "no") == 0 || g_ascii_strcasecmp (is_mime_str, "false") == 0)) {
- ctx->is_mime = FALSE;
- }
- else {
- ctx->is_mime = TRUE;
- }
-#ifndef BUILD_STATIC
+ /* Maps events */
+ start_map_watch ();
+ /* Check whether we are mime worker */
+ is_mime_str = g_hash_table_lookup (worker->cf->params, "mime");
+ if (is_mime_str != NULL
+ && (g_ascii_strcasecmp (is_mime_str, "no") == 0
+ || g_ascii_strcasecmp (is_mime_str, "false") == 0))
+ {
+ ctx->is_mime = FALSE;
}
+ else
+ {
+ ctx->is_mime = TRUE;
+ }
+#ifndef BUILD_STATIC
+ }
#endif
- ctx->resolver = dns_resolver_init (worker->srv->cfg);
+ ctx->resolver = dns_resolver_init (worker->srv->cfg);
- event_loop (0);
-
-#ifndef BUILD_STATIC
- if (ctx->is_custom) {
- unload_custom_filters (ctx);
- }
+ event_loop (0);
+
+#ifndef BUILD_STATIC
+ if (ctx->is_custom)
+ {
+ unload_custom_filters (ctx);
+ }
#endif
- close_log ();
- exit (EXIT_SUCCESS);
+ close_log ();
+ exit (EXIT_SUCCESS);
}
/*
projects / rspamd.git / commitdiff