"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/lib/event-filter.c" between
dovecot-2.3.16.tar.gz and dovecot-2.3.17.tar.gz

About: Dovecot is an IMAP and POP3 server, written with security primarily in mind.

event-filter.c  (dovecot-2.3.16)	:	event-filter.c  (dovecot-2.3.17)
skipping to change at line 223		skipping to change at line 223
{		{
unsigned int i;		unsigned int i;
for (i = 0; i < N_ELEMENTS(event_filter_log_type_map); i++) {		for (i = 0; i < N_ELEMENTS(event_filter_log_type_map); i++) {
if (event_filter_log_type_map[i].log_type == log_type)		if (event_filter_log_type_map[i].log_type == log_type)
return event_filter_log_type_map[i].name;		return event_filter_log_type_map[i].name;
}		}
i_unreached();		i_unreached();
}		}
static void
event_filter_add_categories(pool_t pool,
struct event_filter_node **root,
const char *const *categories)
{
unsigned int categories_count = str_array_length(categories);
unsigned int i;
if (categories_count == 0)
return;
for (i = 0; i < categories_count; i++) {
struct event_filter_node *node;
node = p_new(pool, struct event_filter_node, 1);
node->type = EVENT_FILTER_NODE_TYPE_EVENT_CATEGORY;
node->op = EVENT_FILTER_OP_CMP_EQ;
if (!event_filter_category_to_log_type(categories[i], &node->cate
gory.log_type)) {
node->category.name = p_strdup(pool, categories[i]);
node->category.ptr = event_category_find_registered(categ
ories[i]);
}
add_node(pool, root, node, EVENT_FILTER_OP_AND);
}
}
static void
event_filter_add_fields(pool_t pool,
struct event_filter_node **root,
const struct event_filter_field *fields)
{
unsigned int i;
if (fields == NULL)
return;
for (i = 0; fields[i].key != NULL; i++) {
struct event_filter_node *node;
node = p_new(pool, struct event_filter_node, 1);
node->type = EVENT_FILTER_NODE_TYPE_EVENT_FIELD_WILDCARD;
node->op = EVENT_FILTER_OP_CMP_EQ;
node->field.key = p_strdup(pool, fields[i].key);
node->field.value.str = p_strdup(pool, fields[i].value);
/* Filter currently supports only comparing strings
and numbers. */
if (str_to_intmax(fields[i].value, &node->field.value.intmax) < 0
) {
/* not a number - no problem
Either we have a string, or a number with wildcards */
node->field.value.intmax = INT_MIN;
}
add_node(pool, root, node, EVENT_FILTER_OP_AND);
}
}
void event_filter_add(struct event_filter *filter,
const struct event_filter_query *query)
{
struct event_filter_query_internal *int_query;
struct event_filter_node *expr = NULL;
if (query->name != NULL) {
struct event_filter_node *node;
node = p_new(filter->pool, struct event_filter_node, 1);
node->type = EVENT_FILTER_NODE_TYPE_EVENT_NAME_WILDCARD;
node->op = EVENT_FILTER_OP_CMP_EQ;
node->str = p_strdup(filter->pool, query->name);
if (wildcard_is_literal(query->name))
node->type = EVENT_FILTER_NODE_TYPE_EVENT_NAME_EXACT;
add_node(filter->pool, &expr, node, EVENT_FILTER_OP_AND);
}
if ((query->source_filename != NULL) && (query->source_filename[0] != '\0
')) {
struct event_filter_node *node;
node = p_new(filter->pool, struct event_filter_node, 1);
node->type = EVENT_FILTER_NODE_TYPE_EVENT_SOURCE_LOCATION;
node->op = EVENT_FILTER_OP_CMP_EQ;
node->str = p_strdup(filter->pool, query->source_filename);
node->intmax = query->source_linenum;
add_node(filter->pool, &expr, node, EVENT_FILTER_OP_AND);
}
event_filter_add_categories(filter->pool, &expr, query->categories);
event_filter_add_fields(filter->pool, &expr, query->fields);
if (expr == NULL)
return; /* completely empty query - ignore it */
int_query = event_filter_get_or_alloc_internal_query(filter, query->conte
xt);
if (query->name == NULL)
filter->named_queries_only = FALSE;
/* OR the new expression with existing query */
add_node(filter->pool, &int_query->expr, expr, EVENT_FILTER_OP_OR);
}
static struct event_filter_node *		static struct event_filter_node *
clone_expr(pool_t pool, struct event_filter_node *old)		clone_expr(pool_t pool, struct event_filter_node *old)
{		{
struct event_filter_node *new;		struct event_filter_node *new;
if (old == NULL)		if (old == NULL)
return NULL;		return NULL;
new = p_new(pool, struct event_filter_node, 1);		new = p_new(pool, struct event_filter_node, 1);
new->type = old->type;		new->type = old->type;
skipping to change at line 372		skipping to change at line 269
struct event_filter_query_internal *new;		struct event_filter_query_internal *new;
new = event_filter_get_or_alloc_internal_query(dest, context);		new = event_filter_get_or_alloc_internal_query(dest, context);
add_node(dest->pool, &new->expr,		add_node(dest->pool, &new->expr,
clone_expr(dest->pool, int_query->expr),		clone_expr(dest->pool, int_query->expr),
EVENT_FILTER_OP_OR);		EVENT_FILTER_OP_OR);
} T_END;		} T_END;
}		}
		bool event_filter_remove_queries_with_context(struct event_filter *filter,
		void *context)
		{
		const struct event_filter_query_internal *int_query;
		unsigned int idx;
		array_foreach(&filter->queries, int_query) {
		if (int_query->context == context) {
		idx = array_foreach_idx(&filter->queries, int_query);
		array_delete(&filter->queries, idx, 1);
		return TRUE;
		}
		}
		return FALSE;
		}
void event_filter_merge(struct event_filter *dest,		void event_filter_merge(struct event_filter *dest,
const struct event_filter *src)		const struct event_filter *src)
{		{
event_filter_merge_with_context_internal(dest, src, NULL, FALSE);		event_filter_merge_with_context_internal(dest, src, NULL, FALSE);
}		}
void event_filter_merge_with_context(struct event_filter *dest,		void event_filter_merge_with_context(struct event_filter *dest,
const struct event_filter *src,		const struct event_filter *src,
void *new_context)		void *new_context)
{		{
End of changes. 2 change blocks.
108 lines changed or deleted		16 lines changed or added

---