static gboolean do_motion_event(GtkWidget *tv, GdkEventMotion *e,
GObject *cel)
{
GObject *siglist;
gint x;
gint offset;
GArray *data;
guint nsamples;
GtkTreeViewColumn *col;
gint width;
gdouble scale, *rscale;
GtkAdjustment *adj;
x = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tv), "motion-x"));
g_object_set_data(G_OBJECT(tv), "motion-x", GINT_TO_POINTER((gint)e->x));
adj = g_object_get_data(G_OBJECT(tv), "hadj");
siglist = G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(tv)));
data = g_object_get_data(siglist, "sampledata");
rscale = g_object_get_data(siglist, "rscale");
nsamples = (data->len / g_array_get_element_size(data)) - 1;
col = g_object_get_data(G_OBJECT(tv), "signalcol");
width = gtk_tree_view_column_get_width(col);
g_object_get(cel, "offset", &offset, "scale", &scale, NULL);
offset += x - e->x;
if (offset < 0)
offset = 0;
if (offset > nsamples * *rscale - width)
offset = nsamples * *rscale - width;
gtk_adjustment_set_value(adj, offset);
return TRUE;
}
static unsigned acpi_data_len(GArray *table)
{
#if GLIB_CHECK_VERSION(2, 22, 0)
assert(g_array_get_element_size(table) == 1);
#endif
return table->len;
}
static GArray *summarize(GArray *in, gdouble *scale)
{
GArray *ret;
int skip = 1 / (*scale * 4);
guint64 i, j, k, l;
unsigned unitsize = g_array_get_element_size(in);
uint8_t s[unitsize];
uint8_t smask[unitsize];
g_return_val_if_fail(skip > 1, NULL);
ret = g_array_sized_new(FALSE, FALSE, unitsize, in->len / skip);
ret->len = in->len / skip;
*scale *= skip;
memset(s, 0, unitsize);
for (i = 0, k = 0; i < (in->len/unitsize); i += skip, k++) {
memset(smask, 0xFF, unitsize);
for (j = i; j < i+skip; j++) {
for (l = 0; l < unitsize; l++) {
uint8_t ns = (in->data[(j*unitsize)+l] ^ s[l]) & smask[l];
/* ns is now bits we need to toggle */
s[l] ^= ns;
smask[l] &= ~ns;
}
}
memcpy(&ret->data[k*unitsize], s, unitsize);
}
return ret;
}
gboolean
rspamd_regexp_search (rspamd_regexp_t *re, const gchar *text, gsize len,
const gchar **start, const gchar **end, gboolean raw,
GArray *captures)
{
pcre *r;
pcre_extra *ext;
#if defined(HAVE_PCRE_JIT) && defined(HAVE_PCRE_JIT_FAST)
pcre_jit_stack *st = NULL;
#endif
const gchar *mt;
gsize remain = 0;
gint rc, match_flags = 0, *ovec, ncaptures, i;
g_assert (re != NULL);
g_assert (text != NULL);
if (len == 0) {
len = strlen (text);
}
if (end != NULL && *end != NULL) {
/* Incremental search */
mt = (*end);
if ((gint)len > (mt - text)) {
remain = len - (mt - text);
}
}
else {
mt = text;
remain = len;
}
if (remain == 0) {
return FALSE;
}
match_flags = PCRE_NEWLINE_ANYCRLF;
if ((re->flags & RSPAMD_REGEXP_FLAG_RAW) || raw) {
r = re->raw_re;
ext = re->raw_extra;
#if defined(HAVE_PCRE_JIT) && defined(HAVE_PCRE_JIT_FAST)
st = re->raw_jstack;
#endif
}
else {
r = re->re;
ext = re->extra;
#if defined(HAVE_PCRE_JIT) && defined(HAVE_PCRE_JIT_FAST)
if (g_utf8_validate (mt, remain, NULL)) {
st = re->jstack;
}
#endif
}
g_assert (r != NULL);
ncaptures = (re->ncaptures + 1) * 3;
ovec = g_alloca (sizeof (gint) * ncaptures);
if (!(re->flags & RSPAMD_REGEXP_FLAG_NOOPT)) {
#ifdef HAVE_PCRE_JIT
# ifdef HAVE_PCRE_JIT_FAST
/* XXX: flags seems to be broken with jit fast path */
g_assert (remain > 0);
g_assert (mt != NULL);
if (st != NULL) {
rc = pcre_jit_exec (r, ext, mt, remain, 0, 0, ovec,
ncaptures, st);
}
else {
rc = pcre_exec (r, ext, mt, remain, 0, match_flags, ovec,
ncaptures);
}
# else
rc = pcre_exec (r, ext, mt, remain, 0, match_flags, ovec,
ncaptures);
#endif
#else
rc = pcre_exec (r, ext, mt, remain, 0, match_flags, ovec,
ncaptures);
#endif
}
else {
rc = pcre_exec (r, ext, mt, remain, 0, match_flags, ovec,
ncaptures);
}
if (rc >= 0) {
if (start) {
*start = mt + ovec[0];
}
if (end) {
*end = mt + ovec[1];
}
if (captures != NULL && rc > 1) {
struct rspamd_re_capture *elt;
g_assert (g_array_get_element_size (captures) ==
sizeof (struct rspamd_re_capture));
g_array_set_size (captures, rc);
for (i = 0; i < rc; i ++) {
elt = &g_array_index (captures, struct rspamd_re_capture, i);
elt->p = mt + ovec[i * 2];
elt->len = (mt + ovec[i * 2 + 1]) - elt->p;
}
}
if (re->flags & RSPAMD_REGEXP_FLAG_FULL_MATCH) {
/* We also ensure that the match is full */
if (ovec[0] != 0 || (guint)ovec[1] < len) {
return FALSE;
}
}
return TRUE;
}
return FALSE;
}
unsigned acpi_data_len(GArray *table)
{
assert(g_array_get_element_size(table) == 1);
return table->len;
}
PyObject *
_pygi_marshal_to_py_array (PyGIInvokeState *state,
PyGICallableCache *callable_cache,
PyGIArgCache *arg_cache,
GIArgument *arg)
{
GArray *array_;
PyObject *py_obj = NULL;
PyGISequenceCache *seq_cache = (PyGISequenceCache *)arg_cache;
gsize processed_items = 0;
/* GArrays make it easier to iterate over arrays
* with different element sizes but requires that
* we allocate a GArray if the argument was a C array
*/
if (seq_cache->array_type == GI_ARRAY_TYPE_C) {
gsize len;
if (seq_cache->fixed_size >= 0) {
g_assert(arg->v_pointer != NULL);
len = seq_cache->fixed_size;
} else if (seq_cache->is_zero_terminated) {
if (arg->v_pointer == NULL) {
len = 0;
} else if (seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
len = strlen (arg->v_pointer);
} else {
len = g_strv_length ((gchar **)arg->v_pointer);
}
} else {
GIArgument *len_arg = state->args[seq_cache->len_arg_index];
PyGIArgCache *arg_cache = _pygi_callable_cache_get_arg (callable_cache,
seq_cache->len_arg_index);
if (!gi_argument_to_gsize (len_arg, &len, arg_cache->type_tag)) {
return NULL;
}
}
array_ = g_array_new (FALSE,
FALSE,
seq_cache->item_size);
if (array_ == NULL) {
PyErr_NoMemory ();
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING && arg->v_pointer != NULL)
g_free (arg->v_pointer);
return NULL;
}
if (array_->data != NULL)
g_free (array_->data);
array_->data = arg->v_pointer;
array_->len = len;
} else {
array_ = arg->v_pointer;
}
if (seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
if (arg->v_pointer == NULL) {
py_obj = PYGLIB_PyBytes_FromString ("");
} else {
py_obj = PYGLIB_PyBytes_FromStringAndSize (array_->data, array_->len);
}
} else {
if (arg->v_pointer == NULL) {
py_obj = PyList_New (0);
} else {
int i;
gsize item_size;
PyGIMarshalToPyFunc item_to_py_marshaller;
PyGIArgCache *item_arg_cache;
py_obj = PyList_New (array_->len);
if (py_obj == NULL)
goto err;
item_arg_cache = seq_cache->item_cache;
item_to_py_marshaller = item_arg_cache->to_py_marshaller;
item_size = g_array_get_element_size (array_);
for (i = 0; i < array_->len; i++) {
GIArgument item_arg = {0};
PyObject *py_item;
/* If we are receiving an array of pointers, simply assign the pointer
* and move on, letting the per-item marshaler deal with the
* various transfer modes and ref counts (e.g. g_variant_ref_sink).
*/
if (seq_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
item_arg.v_pointer = g_ptr_array_index ( ( GPtrArray *)array_, i);
} else if (item_arg_cache->is_pointer) {
item_arg.v_pointer = g_array_index (array_, gpointer, i);
} else if (item_arg_cache->type_tag == GI_TYPE_TAG_INTERFACE) {
PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *) item_arg_cache;
// FIXME: This probably doesn't work with boxed types or gvalues. See fx. _pygi_marshal_from_py_array()
switch (g_base_info_get_type (iface_cache->interface_info)) {
case GI_INFO_TYPE_STRUCT:
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING &&
!g_type_is_a (iface_cache->g_type, G_TYPE_BOXED)) {
/* array elements are structs */
gpointer *_struct = g_malloc (item_size);
memcpy (_struct, array_->data + i * item_size,
item_size);
item_arg.v_pointer = _struct;
} else {
item_arg.v_pointer = array_->data + i * item_size;
}
break;
default:
item_arg.v_pointer = g_array_index (array_, gpointer, i);
break;
}
} else {
memcpy (&item_arg, array_->data + i * item_size, item_size);
}
py_item = item_to_py_marshaller ( state,
callable_cache,
item_arg_cache,
&item_arg);
if (py_item == NULL) {
Py_CLEAR (py_obj);
if (seq_cache->array_type == GI_ARRAY_TYPE_C)
g_array_unref (array_);
goto err;
}
PyList_SET_ITEM (py_obj, i, py_item);
processed_items++;
}
}
}
if (seq_cache->array_type == GI_ARRAY_TYPE_C)
g_array_free (array_, FALSE);
return py_obj;
err:
if (seq_cache->array_type == GI_ARRAY_TYPE_C) {
g_array_free (array_, arg_cache->transfer == GI_TRANSFER_EVERYTHING);
} else {
/* clean up unprocessed items */
if (seq_cache->item_cache->to_py_cleanup != NULL) {
int j;
PyGIMarshalCleanupFunc cleanup_func = seq_cache->item_cache->to_py_cleanup;
for (j = processed_items; j < array_->len; j++) {
cleanup_func (state,
seq_cache->item_cache,
NULL,
g_array_index (array_, gpointer, j),
FALSE);
}
}
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING)
g_array_free (array_, TRUE);
}
return NULL;
}
/**
* _pygi_argument_to_object:
* @arg: The argument to convert to an object.
* @type_info: Type info for @arg
* @transfer:
*
* If the argument is of type array, it must be encoded in a GArray, by calling
* _pygi_argument_to_array(). This logic can not be folded into this method
* as determining array lengths may require access to method call arguments.
*
* Returns: A PyObject representing @arg
*/
PyObject *
_pygi_argument_to_object (GIArgument *arg,
GITypeInfo *type_info,
GITransfer transfer)
{
GITypeTag type_tag;
PyObject *object = NULL;
type_tag = g_type_info_get_tag (type_info);
object = _pygi_marshal_to_py_basic_type (arg, type_tag, transfer);
if (object)
return object;
switch (type_tag) {
case GI_TYPE_TAG_VOID:
{
if (g_type_info_is_pointer (type_info)) {
g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
object = PyLong_FromVoidPtr (arg->v_pointer);
}
break;
}
case GI_TYPE_TAG_ARRAY:
{
/* Arrays are assumed to be packed in a GArray */
GArray *array;
GITypeInfo *item_type_info;
GITypeTag item_type_tag;
GITransfer item_transfer;
gsize i, item_size;
if (arg->v_pointer == NULL)
return PyList_New (0);
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_type_tag = g_type_info_get_tag (item_type_info);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
array = arg->v_pointer;
item_size = g_array_get_element_size (array);
if (G_UNLIKELY (item_size > sizeof(GIArgument))) {
g_critical ("Stack overflow protection. "
"Can't copy array element into GIArgument.");
return PyList_New (0);
}
if (item_type_tag == GI_TYPE_TAG_UINT8) {
/* Return as a byte array */
object = PYGLIB_PyBytes_FromStringAndSize (array->data, array->len);
} else {
object = PyList_New (array->len);
if (object == NULL) {
g_critical ("Failure to allocate array for %u items", array->len);
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
for (i = 0; i < array->len; i++) {
GIArgument item = { 0 };
PyObject *py_item;
memcpy (&item, array->data + i * item_size, item_size);
py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
if (py_item == NULL) {
Py_CLEAR (object);
_PyGI_ERROR_PREFIX ("Item %zu: ", i);
break;
}
PyList_SET_ITEM (object, i, py_item);
}
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
info = g_type_info_get_interface (type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_CALLBACK:
{
g_assert_not_reached();
}
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
{
PyObject *py_type;
GType g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) &&
(g_struct_info_is_foreign ((GIStructInfo *) info));
/* Special case variant and none to force loading from py module. */
if (g_type == G_TYPE_VARIANT || g_type == G_TYPE_NONE) {
py_type = _pygi_type_import_by_gi_info (info);
} else {
py_type = _pygi_type_get_from_g_type (g_type);
}
object = pygi_arg_struct_to_py_marshal (arg,
info, /*interface_info*/
g_type,
py_type,
transfer,
FALSE, /*is_allocated*/
is_foreign);
Py_XDECREF (py_type);
break;
}
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
{
GType type;
type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
if (type == G_TYPE_NONE) {
/* An enum with a GType of None is an enum without GType */
PyObject *py_type = _pygi_type_import_by_gi_info (info);
PyObject *py_args = NULL;
if (!py_type)
return NULL;
py_args = PyTuple_New (1);
if (PyTuple_SetItem (py_args, 0, PyLong_FromLong (arg->v_int)) != 0) {
Py_DECREF (py_args);
Py_DECREF (py_type);
return NULL;
}
object = PyObject_CallFunction (py_type, "i", arg->v_int);
Py_DECREF (py_args);
Py_DECREF (py_type);
} else if (info_type == GI_INFO_TYPE_ENUM) {
object = pyg_enum_from_gtype (type, arg->v_int);
} else {
object = pyg_flags_from_gtype (type, arg->v_uint);
}
break;
}
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
object = pygi_arg_gobject_to_py_called_from_c (arg, transfer);
break;
default:
g_assert_not_reached();
}
g_base_info_unref (info);
break;
}
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
{
GSList *list;
gsize length;
GITypeInfo *item_type_info;
GITransfer item_transfer;
gsize i;
list = arg->v_pointer;
length = g_slist_length (list);
object = PyList_New (length);
if (object == NULL) {
break;
}
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
for (i = 0; list != NULL; list = g_slist_next (list), i++) {
GIArgument item;
PyObject *py_item;
item.v_pointer = list->data;
py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
if (py_item == NULL) {
Py_CLEAR (object);
_PyGI_ERROR_PREFIX ("Item %zu: ", i);
break;
}
PyList_SET_ITEM (object, i, py_item);
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
break;
}
case GI_TYPE_TAG_GHASH:
{
GITypeInfo *key_type_info;
GITypeInfo *value_type_info;
GITransfer item_transfer;
GHashTableIter hash_table_iter;
GIArgument key;
GIArgument value;
if (arg->v_pointer == NULL) {
object = Py_None;
Py_INCREF (object);
break;
}
object = PyDict_New();
if (object == NULL) {
break;
}
key_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (key_type_info != NULL);
g_assert (g_type_info_get_tag (key_type_info) != GI_TYPE_TAG_VOID);
value_type_info = g_type_info_get_param_type (type_info, 1);
g_assert (value_type_info != NULL);
g_assert (g_type_info_get_tag (value_type_info) != GI_TYPE_TAG_VOID);
item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
g_hash_table_iter_init (&hash_table_iter, (GHashTable *) arg->v_pointer);
while (g_hash_table_iter_next (&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
PyObject *py_key;
PyObject *py_value;
int retval;
py_key = _pygi_argument_to_object (&key, key_type_info, item_transfer);
if (py_key == NULL) {
break;
}
_pygi_hash_pointer_to_arg (&value, g_type_info_get_tag (value_type_info));
py_value = _pygi_argument_to_object (&value, value_type_info, item_transfer);
if (py_value == NULL) {
Py_DECREF (py_key);
break;
}
retval = PyDict_SetItem (object, py_key, py_value);
Py_DECREF (py_key);
Py_DECREF (py_value);
if (retval < 0) {
Py_CLEAR (object);
break;
}
}
g_base_info_unref ( (GIBaseInfo *) key_type_info);
g_base_info_unref ( (GIBaseInfo *) value_type_info);
break;
}
case GI_TYPE_TAG_ERROR:
{
GError *error = (GError *) arg->v_pointer;
if (error != NULL && transfer == GI_TRANSFER_NOTHING) {
/* If we have not been transferred the ownership we must copy
* the error, because pygi_error_check() is going to free it.
*/
error = g_error_copy (error);
}
if (pygi_error_check (&error)) {
PyObject *err_type;
PyObject *err_value;
PyObject *err_trace;
PyErr_Fetch (&err_type, &err_value, &err_trace);
Py_XDECREF (err_type);
Py_XDECREF (err_trace);
object = err_value;
} else {
object = Py_None;
Py_INCREF (object);
break;
}
break;
}
default:
{
g_assert_not_reached();
}
}
return object;
}
void sigview_zoom(GtkWidget *sigview, gdouble zoom, gint offset)
{
GObject *siglist;
GtkTreeViewColumn *col;
GtkCellRendererSignal *cel;
GtkAdjustment *adj;
/* data and scale refer to summary */
GArray *data;
gdouble scale;
/* rdata and rscale refer to complete data */
GArray *rdata;
gdouble *rscale;
gint ofs;
gint width;
guint nsamples;
/* This is so that sigview_zoom() may be called with pointer
* to the GtkTreeView or containing GtkScrolledWindow, as is the
* case when called from outside this module.
*/
if (GTK_IS_SCROLLED_WINDOW(sigview))
sigview = gtk_bin_get_child(GTK_BIN(sigview));
g_return_if_fail(GTK_IS_TREE_VIEW(sigview));
col = g_object_get_data(G_OBJECT(sigview), "signalcol");
adj = g_object_get_data(G_OBJECT(sigview), "hadj");
width = gtk_tree_view_column_get_width(col);
siglist = G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(sigview)));
rdata = g_object_get_data(siglist, "sampledata");
rscale = g_object_get_data(siglist, "rscale");
if (!rscale) {
rscale = g_malloc(sizeof(rscale));
*rscale = 1;
g_object_set_data(siglist, "rscale", rscale);
}
data = g_object_get_data(siglist, "summarydata");
if (!rdata)
return;
if (!data)
data = rdata;
nsamples = (rdata->len / g_array_get_element_size(rdata)) - 1;
if ((fabs(*rscale - (double)width/nsamples) < 1e-12) && (zoom < 1))
return;
cel = g_object_get_data(G_OBJECT(sigview), "signalcel");
g_object_get(cel, "scale", &scale, "offset", &ofs, NULL);
ofs += offset;
scale *= zoom;
*rscale *= zoom;
ofs *= zoom;
ofs -= offset;
if (ofs < 0)
ofs = 0;
if (*rscale < (double)width/nsamples) {
*rscale = (double)width/nsamples;
scale = *rscale;
if (data && (data != rdata))
g_array_free(data, TRUE);
data = rdata;
}
if (ofs > nsamples * *rscale - width)
ofs = nsamples * *rscale - width;
gtk_adjustment_configure(adj, ofs, 0, nsamples * *rscale,
width/16, width/2, width);
if (scale < 0.125) {
g_object_set_data(siglist,
"summarydata", summarize(data, &scale));
if (data && (data != rdata))
g_array_free(data, TRUE);
} else if ((scale > 1) && (*rscale < 1)) {
scale = *rscale;
g_object_set_data(siglist,
"summarydata", summarize(rdata, &scale));
if (data && (data != rdata))
g_array_free(data, TRUE);
}
g_object_set(cel, "scale", scale, "offset", ofs, NULL);
gtk_widget_queue_draw(GTK_WIDGET(sigview));
}
/* PCRE 2 version */
gboolean
rspamd_regexp_search (rspamd_regexp_t *re, const gchar *text, gsize len,
const gchar **start, const gchar **end, gboolean raw,
GArray *captures)
{
pcre2_match_data *match_data;
pcre2_match_context *mcontext;
PCRE_T *r;
const gchar *mt;
gsize remain = 0, *ovec;
gint rc, match_flags, novec, i;
gboolean ret = FALSE;
g_assert (re != NULL);
g_assert (text != NULL);
if (len == 0) {
len = strlen (text);
}
if (end != NULL && *end != NULL) {
/* Incremental search */
mt = (*end);
if ((gint)len > (mt - text)) {
remain = len - (mt - text);
}
}
else {
mt = text;
remain = len;
}
if (remain == 0) {
return FALSE;
}
match_flags = 0;
if (raw || re->re == re->raw_re) {
r = re->raw_re;
mcontext = re->raw_mcontext;
}
else {
r = re->re;
mcontext = re->mcontext;
}
match_data = pcre2_match_data_create (re->ncaptures + 1, NULL);
#ifdef HAVE_PCRE_JIT
if (!(re->flags & RSPAMD_REGEXP_FLAG_DISABLE_JIT) && can_jit) {
if (re->re != re->raw_re && !g_utf8_validate (mt, remain, NULL)) {
msg_err ("bad utf8 input for JIT re");
return FALSE;
}
rc = pcre2_jit_match (r, mt, remain, 0, match_flags, match_data,
mcontext);
}
else {
rc = pcre2_match (r, mt, remain, 0, match_flags, match_data,
mcontext);
}
#else
rc = pcre2_match (r, mt, remain, 0, match_flags, match_data,
mcontext);
#endif
if (rc >= 0) {
novec = pcre2_get_ovector_count (match_data);
ovec = pcre2_get_ovector_pointer (match_data);
if (start) {
*start = mt + ovec[0];
}
if (end) {
*end = mt + ovec[1];
}
if (captures != NULL && novec > 1) {
struct rspamd_re_capture *elt;
g_assert (g_array_get_element_size (captures) ==
sizeof (struct rspamd_re_capture));
g_array_set_size (captures, novec);
for (i = 0; i < novec; i ++) {
elt = &g_array_index (captures, struct rspamd_re_capture, i);
elt->p = mt + ovec[i * 2];
elt->len = (mt + ovec[i * 2 + 1]) - elt->p;
}
}
ret = TRUE;
if (re->flags & RSPAMD_REGEXP_FLAG_FULL_MATCH) {
/* We also ensure that the match is full */
if (ovec[0] != 0 || (guint)ovec[1] < len) {
ret = FALSE;
}
}
}
