struct rspamd_stat_async_elt*
rspamd_stat_ctx_register_async (rspamd_stat_async_handler handler,
rspamd_stat_async_cleanup cleanup,
gpointer d,
gdouble timeout)
{
struct rspamd_stat_async_elt *elt;
struct rspamd_stat_ctx *st_ctx;
st_ctx = rspamd_stat_get_ctx ();
g_assert (st_ctx != NULL);
elt = g_slice_alloc (sizeof (*elt));
REF_INIT_RETAIN (elt, rspamd_async_elt_dtor);
elt->handler = handler;
elt->cleanup = cleanup;
elt->ud = d;
elt->timeout = timeout;
/* Enabled by default */
elt->enabled = TRUE;
event_set (&elt->timer_ev, -1, EV_TIMEOUT, rspamd_async_elt_on_timer, elt);
event_base_set (st_ctx->ev_base, &elt->timer_ev);
/*
* First we set timeval to zero as we want cb to be executed as
* fast as possible
*/
elt->tv.tv_sec = 0;
elt->tv.tv_usec = 0;
event_add (&elt->timer_ev, &elt->tv);
g_queue_push_tail (st_ctx->async_elts, elt);
return elt;
}
static struct symbols_cache_order *
rspamd_symbols_cache_order_new (gsize nelts)
{
struct symbols_cache_order *ord;
ord = g_slice_alloc (sizeof (*ord));
ord->d = g_ptr_array_sized_new (nelts);
REF_INIT_RETAIN (ord, rspamd_symbols_cache_order_dtor);
return ord;
}
struct rspamd_re_cache *
rspamd_re_cache_new (void)
{
struct rspamd_re_cache *cache;
cache = g_slice_alloc (sizeof (*cache));
cache->re_classes = g_hash_table_new (g_int64_hash, g_int64_equal);
cache->nre = 0;
cache->re = g_ptr_array_new_full (256, rspamd_re_cache_elt_dtor);
#ifdef WITH_HYPERSCAN
cache->hyperscan_loaded = FALSE;
#endif
REF_INIT_RETAIN (cache, rspamd_re_cache_destroy);
return cache;
}
static void
rspamd_map_schedule_periodic (struct rspamd_map *map,
gboolean locked, gboolean initial, gboolean errored)
{
const gdouble error_mult = 20.0, lock_mult = 0.1;
gdouble jittered_sec;
gdouble timeout;
struct map_periodic_cbdata *cbd;
timeout = map->poll_timeout;
if (initial) {
timeout = 0.0;
}
if (errored) {
timeout = map->poll_timeout * error_mult;
}
else if (locked) {
timeout = lock_mult;
}
cbd = g_slice_alloc0 (sizeof (*cbd));
cbd->cbdata.state = 0;
cbd->cbdata.prev_data = *map->user_data;
cbd->cbdata.cur_data = NULL;
cbd->cbdata.map = map;
cbd->map = map;
REF_INIT_RETAIN (cbd, rspamd_map_periodic_dtor);
if (initial) {
evtimer_set (&map->ev, rspamd_map_periodic_callback, cbd);
event_base_set (map->ev_base, &map->ev);
}
else {
evtimer_del (&map->ev);
evtimer_set (&map->ev, rspamd_map_periodic_callback, cbd);
event_base_set (map->ev_base, &map->ev);
}
jittered_sec = rspamd_time_jitter (timeout, 0);
msg_debug_map ("schedule new periodic event %p in %.2f seconds", cbd, jittered_sec);
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
}
struct rspamd_email_address *
rspamd_email_address_from_smtp (const gchar *str, guint len)
{
struct rspamd_email_address addr, *ret;
gsize nlen;
if (str == NULL || len == 0) {
return NULL;
}
rspamd_smtp_addr_parse (str, len, &addr);
if (addr.flags & RSPAMD_EMAIL_ADDR_VALID) {
ret = g_slice_alloc (sizeof (*ret));
memcpy (ret, &addr, sizeof (addr));
if ((ret->flags & RSPAMD_EMAIL_ADDR_QUOTED) && ret->addr[0] == '"') {
if (ret->flags & RSPAMD_EMAIL_ADDR_HAS_BACKSLASH) {
/* We also need to unquote user */
rspamd_email_address_unescape (ret);
}
/* We need to unquote addr */
nlen = ret->domain_len + ret->user_len + 2;
ret->addr = g_malloc (nlen + 1);
ret->addr_len = rspamd_snprintf ((char *)ret->addr, nlen, "%*s@%*s",
(gint)ret->user_len, ret->user,
(gint)ret->domain_len, ret->domain);
ret->flags |= RSPAMD_EMAIL_ADDR_ADDR_ALLOCATED;
}
REF_INIT_RETAIN (ret, rspamd_email_addr_dtor);
return ret;
}
return NULL;
}
/**
* Async HTTP callback
*/
static void
http_callback (gint fd, short what, void *ud)
{
struct rspamd_map *map = ud;
struct http_map_data *data;
struct http_callback_data *cbd;
rspamd_mempool_t *pool;
gchar tmpbuf[PATH_MAX];
data = map->map_data;
pool = map->pool;
if (!g_atomic_int_compare_and_exchange (map->locked, 0, 1)) {
msg_debug_pool (
"don't try to reread map as it is locked by other process, will reread it later");
jitter_timeout_event (map, TRUE, FALSE, FALSE);
return;
}
/* Plan event */
cbd = g_slice_alloc0 (sizeof (struct http_callback_data));
rspamd_snprintf (tmpbuf, sizeof (tmpbuf),
"%s" G_DIR_SEPARATOR_S "rspamd_map%d-XXXXXX",
map->cfg->temp_dir, map->id);
cbd->out_fd = mkstemp (tmpbuf);
if (cbd->out_fd == -1) {
g_slice_free1 (sizeof (*cbd), cbd);
msg_err_pool ("cannot create tempfile: %s", strerror (errno));
jitter_timeout_event (map, FALSE, FALSE, TRUE);
g_atomic_int_set (map->locked, 0);
return;
}
cbd->tmpfile = g_strdup (tmpbuf);
cbd->ev_base = map->ev_base;
cbd->map = map;
cbd->data = data;
cbd->fd = -1;
cbd->cbdata.state = 0;
cbd->cbdata.prev_data = *cbd->map->user_data;
cbd->cbdata.cur_data = NULL;
cbd->cbdata.map = cbd->map;
cbd->stage = map_resolve_host2;
double_to_tv (map->cfg->map_timeout, &cbd->tv);
REF_INIT_RETAIN (cbd, free_http_cbdata);
msg_debug_pool ("reading map data from %s", data->host);
/* Send both A and AAAA requests */
if (map->r->r) {
if (rdns_make_request_full (map->r->r, rspamd_map_dns_callback, cbd,
map->cfg->dns_timeout, map->cfg->dns_retransmits, 1,
data->host, RDNS_REQUEST_A)) {
REF_RETAIN (cbd);
}
if (rdns_make_request_full (map->r->r, rspamd_map_dns_callback, cbd,
map->cfg->dns_timeout, map->cfg->dns_retransmits, 1,
data->host, RDNS_REQUEST_AAAA)) {
REF_RETAIN (cbd);
}
jitter_timeout_event (map, FALSE, FALSE, FALSE);
map->dtor = free_http_cbdata_dtor;
map->dtor_data = cbd;
}
else {
msg_warn_pool ("cannot load map: DNS resolver is not initialized");
jitter_timeout_event (map, FALSE, FALSE, TRUE);
}
/* We don't need own ref as it is now refcounted by DNS requests */
REF_RELEASE (cbd);
}
rspamd_regexp_t*
rspamd_regexp_new (const gchar *pattern, const gchar *flags,
GError **err)
{
const gchar *start = pattern, *end, *flags_str = NULL, *err_str;
rspamd_regexp_t *res;
pcre *r;
gchar sep = 0, *real_pattern;
gint regexp_flags = 0, rspamd_flags = 0, err_off, study_flags = 0, ncaptures;
gboolean strict_flags = FALSE;
rspamd_regexp_library_init ();
if (flags == NULL) {
/* We need to parse pattern and detect flags set */
if (*start == '/') {
sep = '/';
}
else if (*start == 'm') {
start ++;
sep = *start;
/* Paired braces */
if (sep == '{') {
sep = '}';
}
rspamd_flags |= RSPAMD_REGEXP_FLAG_FULL_MATCH;
}
if (sep == '\0' || g_ascii_isalnum (sep)) {
/* We have no flags, no separators and just use all line as expr */
start = pattern;
end = start + strlen (pattern);
rspamd_flags &= ~RSPAMD_REGEXP_FLAG_FULL_MATCH;
}
else {
end = strrchr (pattern, sep);
if (end == NULL || end <= start) {
g_set_error (err, rspamd_regexp_quark(), EINVAL,
"pattern is not enclosed with %c: %s",
sep, pattern);
return NULL;
}
flags_str = end + 1;
start ++;
}
}
else {
/* Strictly check all flags */
strict_flags = TRUE;
start = pattern;
end = pattern + strlen (pattern);
flags_str = flags;
}
rspamd_flags |= RSPAMD_REGEXP_FLAG_RAW;
regexp_flags &= ~PCRE_UTF8;
if (flags_str != NULL) {
while (*flags_str) {
switch (*flags_str) {
case 'i':
regexp_flags |= PCRE_CASELESS;
break;
case 'm':
regexp_flags |= PCRE_MULTILINE;
break;
case 's':
regexp_flags |= PCRE_DOTALL;
break;
case 'x':
regexp_flags |= PCRE_EXTENDED;
break;
case 'u':
rspamd_flags &= ~RSPAMD_REGEXP_FLAG_RAW;
regexp_flags |= PCRE_UTF8;
break;
case 'O':
/* We optimize all regexps by default */
rspamd_flags |= RSPAMD_REGEXP_FLAG_NOOPT;
break;
case 'r':
rspamd_flags |= RSPAMD_REGEXP_FLAG_RAW;
regexp_flags &= ~PCRE_UTF8;
break;
default:
if (strict_flags) {
g_set_error (err, rspamd_regexp_quark(), EINVAL,
"invalid regexp flag: %c in pattern %s",
*flags_str, pattern);
return NULL;
}
msg_warn ("invalid flag '%c' in pattern %s", *flags_str, pattern);
goto fin;
break;
}
flags_str++;
}
}
fin:
real_pattern = g_malloc (end - start + 1);
rspamd_strlcpy (real_pattern, start, end - start + 1);
r = pcre_compile (real_pattern, regexp_flags, &err_str, &err_off, NULL);
if (r == NULL) {
g_set_error (err, rspamd_regexp_quark(), EINVAL,
"invalid regexp pattern: '%s': %s at position %d",
pattern, err_str, err_off);
g_free (real_pattern);
return NULL;
}
/* Now allocate the target structure */
res = g_slice_alloc0 (sizeof (*res));
REF_INIT_RETAIN (res, rspamd_regexp_dtor);
res->flags = rspamd_flags;
res->pattern = real_pattern;
if (rspamd_flags & RSPAMD_REGEXP_FLAG_RAW) {
res->raw_re = r;
}
else {
res->re = r;
res->raw_re = pcre_compile (pattern, regexp_flags & ~PCRE_UTF8,
&err_str, &err_off, NULL);
if (res->raw_re == NULL) {
msg_warn ("invalid raw regexp pattern: '%s': %s at position %d",
pattern, err_str, err_off);
}
}
#ifdef HAVE_PCRE_JIT
study_flags |= PCRE_STUDY_JIT_COMPILE;
#endif
if (!(rspamd_flags & RSPAMD_REGEXP_FLAG_NOOPT)) {
/* Optimize regexp */
if (res->re) {
res->extra = pcre_study (res->re, study_flags, &err_str);
if (res->extra != NULL) {
#ifdef HAVE_PCRE_JIT
gint jit, n;
if (can_jit) {
jit = 0;
n = pcre_fullinfo (res->re, res->extra,
PCRE_INFO_JIT, &jit);
if (n != 0 || jit != 1) {
msg_debug ("jit compilation of %s is not supported", pattern);
res->jstack = NULL;
}
else {
res->jstack = pcre_jit_stack_alloc (32 * 1024, 512 * 1024);
pcre_assign_jit_stack (res->extra, NULL, res->jstack);
}
}
#endif
}
else {
msg_warn ("cannot optimize regexp pattern: '%s': %s",
pattern, err_str);
}
}
if (res->raw_re) {
if (res->raw_re != res->re) {
res->raw_extra = pcre_study (res->raw_re, study_flags, &err_str);
if (res->raw_extra != NULL) {
#ifdef HAVE_PCRE_JIT
gint jit, n;
if (can_jit) {
jit = 0;
n = pcre_fullinfo (res->raw_re, res->raw_extra,
PCRE_INFO_JIT, &jit);
if (n != 0 || jit != 1) {
msg_debug ("jit compilation of %s is not supported",
pattern);
res->raw_jstack = NULL;
}
else {
res->raw_jstack = pcre_jit_stack_alloc (32 * 1024,
512 * 1024);
pcre_assign_jit_stack (res->raw_extra, NULL,
res->raw_jstack);
}
}
#endif
}
else {
msg_warn ("cannot optimize raw regexp pattern: '%s': %s",
pattern, err_str);
}
}
else {
#ifdef HAVE_PCRE_JIT
/* Just alias pointers */
res->raw_extra = res->extra;
res->raw_jstack = res->jstack;
#endif
}
}
}
rspamd_regexp_generate_id (pattern, flags, res->id);
/* Check number of captures */
if (pcre_fullinfo (res->raw_re, res->extra, PCRE_INFO_CAPTURECOUNT,
&ncaptures) == 0) {
res->ncaptures = ncaptures;
}
return res;
}
void*
rspamd_fuzzy_backend_init_redis (struct rspamd_fuzzy_backend *bk,
const ucl_object_t *obj, struct rspamd_config *cfg, GError **err)
{
struct rspamd_fuzzy_backend_redis *backend;
const ucl_object_t *elt;
gboolean ret = FALSE;
guchar id_hash[rspamd_cryptobox_HASHBYTES];
rspamd_cryptobox_hash_state_t st;
backend = g_slice_alloc0 (sizeof (*backend));
backend->timeout = REDIS_DEFAULT_TIMEOUT;
backend->redis_object = REDIS_DEFAULT_OBJECT;
ret = rspamd_fuzzy_backend_redis_try_ucl (backend, obj, cfg);
/* Now try global redis settings */
if (!ret) {
elt = ucl_object_lookup (cfg->rcl_obj, "redis");
if (elt) {
const ucl_object_t *specific_obj;
specific_obj = ucl_object_lookup_any (elt, "fuzzy", "fuzzy_storage",
NULL);
if (specific_obj) {
ret = rspamd_fuzzy_backend_redis_try_ucl (backend, specific_obj,
cfg);
}
else {
ret = rspamd_fuzzy_backend_redis_try_ucl (backend, elt, cfg);
}
}
}
if (!ret) {
msg_err_config ("cannot init redis backend for fuzzy storage");
g_slice_free1 (sizeof (*backend), backend);
return NULL;
}
REF_INIT_RETAIN (backend, rspamd_fuzzy_backend_redis_dtor);
backend->pool = cfg->redis_pool;
rspamd_cryptobox_hash_init (&st, NULL, 0);
rspamd_cryptobox_hash_update (&st, backend->redis_object,
strlen (backend->redis_object));
if (backend->dbname) {
rspamd_cryptobox_hash_update (&st, backend->dbname,
strlen (backend->dbname));
}
if (backend->password) {
rspamd_cryptobox_hash_update (&st, backend->password,
strlen (backend->password));
}
rspamd_cryptobox_hash_final (&st, id_hash);
backend->id = rspamd_encode_base32 (id_hash, sizeof (id_hash));
return backend;
}
/**
* Async HTTP callback
*/
static void
rspamd_map_common_http_callback (struct rspamd_map *map, struct rspamd_map_backend *bk,
struct map_periodic_cbdata *periodic, gboolean check)
{
struct http_map_data *data;
struct http_callback_data *cbd;
data = bk->data.hd;
if (g_atomic_int_get (&map->cache->available) == 1) {
/* Read cached data */
if (check) {
if (data->last_checked < map->cache->last_checked) {
periodic->need_modify = TRUE;
/* Reset the whole chain */
periodic->cur_backend = 0;
rspamd_map_periodic_callback (-1, EV_TIMEOUT, periodic);
}
return;
}
else if (rspamd_map_read_cached (map, periodic, data->host)) {
/* Switch to the next backend */
periodic->cur_backend ++;
rspamd_map_periodic_callback (-1, EV_TIMEOUT, periodic);
data->last_checked = map->cache->last_checked;
return;
}
}
cbd = g_slice_alloc0 (sizeof (struct http_callback_data));
cbd->ev_base = map->ev_base;
cbd->map = map;
cbd->data = data;
cbd->fd = -1;
cbd->check = check;
cbd->periodic = periodic;
MAP_RETAIN (periodic, "periodic");
cbd->bk = bk;
MAP_RETAIN (bk, "rspamd_map_backend");
cbd->stage = map_resolve_host2;
double_to_tv (map->cfg->map_timeout, &cbd->tv);
REF_INIT_RETAIN (cbd, free_http_cbdata);
msg_debug_map ("%s map data from %s", check ? "checking" : "reading",
data->host);
/* Send both A and AAAA requests */
if (map->r->r) {
if (rdns_make_request_full (map->r->r, rspamd_map_dns_callback, cbd,
map->cfg->dns_timeout, map->cfg->dns_retransmits, 1,
data->host, RDNS_REQUEST_A)) {
MAP_RETAIN (cbd, "http_callback_data");
}
if (rdns_make_request_full (map->r->r, rspamd_map_dns_callback, cbd,
map->cfg->dns_timeout, map->cfg->dns_retransmits, 1,
data->host, RDNS_REQUEST_AAAA)) {
MAP_RETAIN (cbd, "http_callback_data");
}
map->dtor = free_http_cbdata_dtor;
map->dtor_data = cbd;
}
else {
msg_warn_map ("cannot load map: DNS resolver is not initialized");
cbd->periodic->errored = TRUE;
}
/* We don't need own ref as it is now ref counted by DNS handlers */
MAP_RELEASE (cbd, "http_callback_data");
}
static struct rspamd_map_backend *
rspamd_map_parse_backend (struct rspamd_config *cfg, const gchar *map_line)
{
struct rspamd_map_backend *bk;
struct file_map_data *fdata = NULL;
struct http_map_data *hdata = NULL;
struct http_parser_url up;
rspamd_ftok_t tok;
bk = g_slice_alloc0 (sizeof (*bk));
REF_INIT_RETAIN (bk, rspamd_map_backend_dtor);
if (!rspamd_map_check_proto (cfg, map_line, bk)) {
goto err;
}
/* Now check for each proto separately */
if (bk->protocol == MAP_PROTO_FILE) {
fdata = g_slice_alloc0 (sizeof (struct file_map_data));
fdata->st.st_mtime = -1;
if (access (bk->uri, R_OK) == -1) {
if (errno != ENOENT) {
msg_err_config ("cannot open file '%s': %s", bk->uri, strerror (errno));
return NULL;
}
msg_info_config (
"map '%s' is not found, but it can be loaded automatically later",
bk->uri);
}
fdata->filename = g_strdup (bk->uri);
bk->data.fd = fdata;
}
else if (bk->protocol == MAP_PROTO_HTTP || bk->protocol == MAP_PROTO_HTTPS) {
hdata = g_slice_alloc0 (sizeof (struct http_map_data));
memset (&up, 0, sizeof (up));
if (http_parser_parse_url (bk->uri, strlen (bk->uri), FALSE,
&up) != 0) {
msg_err_config ("cannot parse HTTP url: %s", bk->uri);
goto err;
}
else {
if (!(up.field_set & 1 << UF_HOST)) {
msg_err_config ("cannot parse HTTP url: %s: no host", bk->uri);
return NULL;
}
tok.begin = bk->uri + up.field_data[UF_HOST].off;
tok.len = up.field_data[UF_HOST].len;
hdata->host = rspamd_ftokdup (&tok);
if (up.field_set & 1 << UF_PORT) {
hdata->port = up.port;
}
else {
if (bk->protocol == MAP_PROTO_HTTP) {
hdata->port = 80;
}
else {
hdata->port = 443;
}
}
if (up.field_set & 1 << UF_PATH) {
tok.begin = bk->uri + up.field_data[UF_PATH].off;
tok.len = strlen (tok.begin);
hdata->path = rspamd_ftokdup (&tok);
}
}
bk->data.hd = hdata;
}
return bk;
err:
MAP_RELEASE (bk, "rspamd_map_backend");
if (hdata) {
g_slice_free1 (sizeof (*hdata), hdata);
}
if (fdata) {
g_slice_free1 (sizeof (*fdata), fdata);
}
return NULL;
}
/**
* Async HTTP callback
*/
static void
rspamd_map_common_http_callback (struct rspamd_map *map, struct rspamd_map_backend *bk,
struct map_periodic_cbdata *periodic, gboolean check)
{
struct http_map_data *data;
struct http_callback_data *cbd;
gchar tmpbuf[PATH_MAX];
data = bk->data.hd;
cbd = g_slice_alloc0 (sizeof (struct http_callback_data));
rspamd_snprintf (tmpbuf, sizeof (tmpbuf),
"%s" G_DIR_SEPARATOR_S "rspamd_map%d-XXXXXX",
map->cfg->temp_dir, map->id);
cbd->out_fd = mkstemp (tmpbuf);
if (cbd->out_fd == -1) {
msg_err_map ("cannot create tempfile: %s", strerror (errno));
g_atomic_int_set (map->locked, 0);
g_slice_free1 (sizeof (*cbd), cbd);
periodic->errored = TRUE;
rspamd_map_periodic_callback (-1, EV_TIMEOUT, periodic);
return;
}
cbd->tmpfile = g_strdup (tmpbuf);
cbd->ev_base = map->ev_base;
cbd->map = map;
cbd->data = data;
cbd->fd = -1;
cbd->check = check;
cbd->periodic = periodic;
MAP_RETAIN (periodic);
cbd->bk = bk;
MAP_RETAIN (bk);
cbd->stage = map_resolve_host2;
double_to_tv (map->cfg->map_timeout, &cbd->tv);
REF_INIT_RETAIN (cbd, free_http_cbdata);
msg_debug_map ("%s map data from %s", check ? "checking" : "reading",
data->host);
/* Send both A and AAAA requests */
if (map->r->r) {
if (rdns_make_request_full (map->r->r, rspamd_map_dns_callback, cbd,
map->cfg->dns_timeout, map->cfg->dns_retransmits, 1,
data->host, RDNS_REQUEST_A)) {
MAP_RETAIN (cbd);
}
if (rdns_make_request_full (map->r->r, rspamd_map_dns_callback, cbd,
map->cfg->dns_timeout, map->cfg->dns_retransmits, 1,
data->host, RDNS_REQUEST_AAAA)) {
MAP_RETAIN (cbd);
}
map->dtor = free_http_cbdata_dtor;
map->dtor_data = cbd;
}
else {
msg_warn_map ("cannot load map: DNS resolver is not initialized");
cbd->periodic->errored = TRUE;
}
/* We don't need own ref as it is now ref counted by DNS handlers */
MAP_RELEASE (cbd);
}
rspamd_regexp_t*
rspamd_regexp_new (const gchar *pattern, const gchar *flags,
GError **err)
{
const gchar *start = pattern, *end, *flags_str = NULL;
gchar *err_str;
rspamd_regexp_t *res;
PCRE_T *r;
gchar sep = 0, *real_pattern;
#ifndef WITH_PCRE2
gint err_off;
#else
gsize err_off;
#endif
gint regexp_flags = 0, rspamd_flags = 0, err_code, ncaptures;
gboolean strict_flags = FALSE;
rspamd_regexp_library_init (NULL);
if (flags == NULL) {
/* We need to parse pattern and detect flags set */
if (*start == '/') {
sep = '/';
}
else if (*start == 'm') {
start ++;
sep = *start;
/* Paired braces */
if (sep == '{') {
sep = '}';
}
rspamd_flags |= RSPAMD_REGEXP_FLAG_FULL_MATCH;
}
if (sep == '\0' || g_ascii_isalnum (sep)) {
/* We have no flags, no separators and just use all line as expr */
start = pattern;
end = start + strlen (pattern);
rspamd_flags &= ~RSPAMD_REGEXP_FLAG_FULL_MATCH;
}
else {
end = strrchr (pattern, sep);
if (end == NULL || end <= start) {
g_set_error (err, rspamd_regexp_quark(), EINVAL,
"pattern is not enclosed with %c: %s",
sep, pattern);
return NULL;
}
flags_str = end + 1;
start ++;
}
}
else {
/* Strictly check all flags */
strict_flags = TRUE;
start = pattern;
end = pattern + strlen (pattern);
flags_str = flags;
}
rspamd_flags |= RSPAMD_REGEXP_FLAG_RAW;
#ifndef WITH_PCRE2
regexp_flags &= ~PCRE_FLAG(UTF8);
regexp_flags |= PCRE_FLAG(NEWLINE_ANYCRLF);
#else
regexp_flags &= ~PCRE_FLAG(UTF);
#endif
if (flags_str != NULL) {
while (*flags_str) {
switch (*flags_str) {
case 'i':
regexp_flags |= PCRE_FLAG(CASELESS);
break;
case 'm':
regexp_flags |= PCRE_FLAG(MULTILINE);
break;
case 's':
regexp_flags |= PCRE_FLAG(DOTALL);
break;
case 'x':
regexp_flags |= PCRE_FLAG(EXTENDED);
break;
case 'u':
rspamd_flags &= ~RSPAMD_REGEXP_FLAG_RAW;
#ifndef WITH_PCRE2
regexp_flags |= PCRE_FLAG(UTF8);
#else
regexp_flags |= PCRE_FLAG(UTF);
#endif
break;
case 'O':
/* We optimize all regexps by default */
rspamd_flags |= RSPAMD_REGEXP_FLAG_NOOPT;
break;
case 'r':
rspamd_flags |= RSPAMD_REGEXP_FLAG_RAW;
#ifndef WITH_PCRE2
regexp_flags &= ~PCRE_FLAG(UTF8);
#else
regexp_flags &= ~PCRE_FLAG(UTF);
#endif
break;
default:
if (strict_flags) {
g_set_error (err, rspamd_regexp_quark(), EINVAL,
"invalid regexp flag: %c in pattern %s",
*flags_str, pattern);
return NULL;
}
msg_warn ("invalid flag '%c' in pattern %s", *flags_str, pattern);
goto fin;
break;
}
flags_str++;
}
}
fin:
real_pattern = g_malloc (end - start + 1);
rspamd_strlcpy (real_pattern, start, end - start + 1);
#ifndef WITH_PCRE2
r = pcre_compile (real_pattern, regexp_flags,
(const char **)&err_str, &err_off, NULL);
(void)err_code;
#else
r = pcre2_compile (real_pattern, PCRE2_ZERO_TERMINATED,
regexp_flags,
&err_code, &err_off, pcre2_ctx);
if (r == NULL) {
err_str = g_alloca (1024);
memset (err_str, 0, 1024);
pcre2_get_error_message (err_code, err_str, 1024);
}
#endif
if (r == NULL) {
g_set_error (err, rspamd_regexp_quark(), EINVAL,
"regexp parsing error: '%s' at position %d",
err_str, (gint)err_off);
g_free (real_pattern);
return NULL;
}
/* Now allocate the target structure */
res = g_malloc0 (sizeof (*res));
REF_INIT_RETAIN (res, rspamd_regexp_dtor);
res->flags = rspamd_flags;
res->pattern = real_pattern;
res->cache_id = RSPAMD_INVALID_ID;
res->pcre_flags = regexp_flags;
res->max_hits = 0;
res->re = r;
if (rspamd_flags & RSPAMD_REGEXP_FLAG_RAW) {
res->raw_re = r;
}
else {
#ifndef WITH_PCRE2
res->raw_re = pcre_compile (real_pattern, regexp_flags & ~PCRE_FLAG(UTF8),
(const char **)&err_str, &err_off, NULL);
(void)err_code;
#else
res->raw_re = pcre2_compile (real_pattern, PCRE2_ZERO_TERMINATED,
regexp_flags & ~PCRE_FLAG(UTF),
&err_code, &err_off, pcre2_ctx);
if (res->raw_re == NULL) {
err_str = g_alloca (1024);
memset (err_str, 0, 1024);
pcre2_get_error_message (err_code, err_str, 1024);
}
#endif
if (res->raw_re == NULL) {
msg_warn ("raw regexp parsing error: '%s': '%s' at position %d",
err_str, real_pattern, (gint)err_off);
}
}
rspamd_regexp_post_process (res);
rspamd_regexp_generate_id (pattern, flags, res->id);
#ifndef WITH_PCRE2
/* Check number of captures */
if (pcre_fullinfo (res->raw_re, res->extra, PCRE_INFO_CAPTURECOUNT,
&ncaptures) == 0) {
res->ncaptures = ncaptures;
}
/* Check number of backrefs */
if (pcre_fullinfo (res->raw_re, res->extra, PCRE_INFO_BACKREFMAX,
&ncaptures) == 0) {
res->nbackref = ncaptures;
}
#else
/* Check number of captures */
if (pcre2_pattern_info (res->raw_re, PCRE2_INFO_CAPTURECOUNT,
&ncaptures) == 0) {
res->ncaptures = ncaptures;
}
/* Check number of backrefs */
if (pcre2_pattern_info (res->raw_re, PCRE2_INFO_BACKREFMAX,
&ncaptures) == 0) {
res->nbackref = ncaptures;
}
#endif
return res;
}
