static void
test_kv_parser_basics(void)
{
LogMessage *msg;
msg = parse_kv_into_log_message("foo=bar");
assert_log_message_value(msg, log_msg_get_value_handle("foo"), "bar");
log_msg_unref(msg);
kv_parser_set_prefix(kv_parser, ".prefix.");
msg = parse_kv_into_log_message("foo=bar");
assert_log_message_value(msg, log_msg_get_value_handle(".prefix.foo"), "bar");
log_msg_unref(msg);
}
static void
test_geoip_parser_basics(void)
{
LogMessage *msg;
msg = parse_geoip_into_log_message("217.20.130.99");
assert_log_message_value(msg, log_msg_get_value_handle(".geoip.country_code"), "HU");
log_msg_unref(msg);
geoip_parser_set_prefix(geoip_parser, ".prefix.");
msg = parse_geoip_into_log_message("217.20.130.99");
assert_log_message_value(msg, log_msg_get_value_handle(".prefix.country_code"), "HU");
log_msg_unref(msg);
}
static void
test_log_message_can_be_cleared(void)
{
LogMessage *msg, *cloned;
msg = construct_log_message_with_all_bells_and_whistles();
cloned = clone_cow_log_message(msg);
assert_log_msg_clear_clears_all_properties(cloned);
log_msg_unref(cloned);
assert_log_msg_clear_clears_all_properties(msg);
log_msg_unref(msg);
}
gpointer
threaded_consume(gpointer st)
{
LogQueue *q = (LogQueue *) st;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gboolean success;
gint i;
for (i = 0; i < 100000; i++)
{
g_static_mutex_lock(&threaded_lock);
msg = NULL;
success = log_queue_pop_head(q, &msg, &path_options, FALSE);
g_static_mutex_unlock(&threaded_lock);
g_assert(!success || (success && msg != NULL));
if (!success)
{
fprintf(stderr, "Queue didn't return enough messages: i=%d\n", i);
return GUINT_TO_POINTER(1);
}
log_msg_ack(msg, &path_options);
log_msg_unref(msg);
}
return NULL;
}
static void
log_center_ack(LogMessage *msg, gpointer user_data)
{
log_msg_ack_block_end(msg);
log_msg_ack(msg);
log_msg_unref(msg);
}
static void
test_rewind_over_eof(LogQueueDiskReliable *dq)
{
LogMessage *msg3 = log_msg_new_mark();
LogMessage *read_message3;
LogPathOptions local_options = LOG_PATH_OPTIONS_INIT;
msg3->ack_func = _dummy_ack;
log_queue_push_tail(&dq->super.super, msg3, &local_options);
gint64 previous_read_head = dq->super.qdisk->hdr->read_head;
read_message3 = log_queue_pop_head(&dq->super.super, &local_options);
assert_true(read_message3 != NULL, ASSERTION_ERROR("Can't read message from queue"));
assert_gint(dq->super.qdisk->hdr->read_head, dq->super.qdisk->hdr->write_head, ASSERTION_ERROR("Read head in bad position"));
assert_true(msg3 == read_message3, ASSERTION_ERROR("Message 3 isn't read from qreliable"));
log_msg_unref(read_message3);
log_queue_rewind_backlog(&dq->super.super, 1);
assert_gint(dq->super.qdisk->hdr->read_head, previous_read_head, ASSERTION_ERROR("Read head is corrupted"));
read_message3 = log_queue_pop_head(&dq->super.super, &local_options);
assert_true(read_message3 != NULL, ASSERTION_ERROR("Can't read message from queue"));
assert_gint(dq->super.qdisk->hdr->read_head, dq->super.qdisk->hdr->write_head, ASSERTION_ERROR("Read head in bad position"));
assert_true(msg3 == read_message3, ASSERTION_ERROR("Message 3 isn't read from qreliable"));
log_msg_drop(msg3, &local_options, AT_PROCESSED);
}
static void
set_mark_message_serialized_size()
{
LogMessage *mark_message = log_msg_new_mark();
mark_message_serialized_size = get_serialized_message_size(mark_message);
log_msg_unref(mark_message);
}
static void
late_ack_tracker_manage_msg_ack(AckTracker *s, LogMessage *msg, AckType ack_type)
{
LateAckTracker *self = (LateAckTracker *)s;
LateAckRecord *ack_rec = (LateAckRecord *)msg->ack_record;
LateAckRecord *last_in_range = NULL;
guint32 ack_range_length = 0;
ack_rec->acked = TRUE;
_late_tracker_lock(self);
{
ack_range_length = _get_continuous_range_length(self);
if (ack_range_length > 0)
{
last_in_range = ring_buffer_element_at(&self->ack_record_storage, ack_range_length - 1);
if (ack_type != AT_ABORTED)
{
Bookmark *bookmark = &(last_in_range->bookmark);
bookmark->save(bookmark);
}
_drop_range(self, ack_range_length);
if (ack_type == AT_SUSPENDED)
log_source_flow_control_suspend(self->super.source);
else
log_source_flow_control_adjust(self->super.source, ack_range_length);
}
}
_late_tracker_unlock(self);
log_msg_unref(msg);
log_pipe_unref((LogPipe *)self->super.source);
}
void
test_rule_value_without_clean(const gchar *program, const gchar *pattern,
const gchar *name, const gchar *value)
{
gboolean result;
LogMessage *msg = log_msg_new_empty();
gboolean found = FALSE;
const gchar *val;
gssize len;
PDBInput input;
log_msg_set_value(msg, LM_V_MESSAGE, pattern, strlen(pattern));
log_msg_set_value(msg, LM_V_PROGRAM, program, 5);
log_msg_set_value(msg, LM_V_HOST, MYHOST, strlen(MYHOST));
log_msg_set_value(msg, LM_V_PID, MYPID, strlen(MYPID));
result = pattern_db_process(patterndb, PDB_INPUT_WRAP_MESSAGE(&input, msg));
val = log_msg_get_value(msg, log_msg_get_value_handle(name), &len);
if (value)
found = strcmp(val, value) == 0;
if (!!value ^ (len > 0))
test_fail("Value '%s' is %smatching for pattern '%s' (%d)\n", name, found ? "" : "not ", pattern, !!result);
log_msg_unref(msg);
}
static void
log_dest_group_queue(LogPipe *s, LogMessage *msg, gint path_flags)
{
LogDestGroup *self = (LogDestGroup *) s;
LogDriver *p;
if ((path_flags & PF_FLOW_CTL_OFF) == 0)
{
log_msg_ref(msg);
log_msg_ack_block_start(msg, log_dest_group_ack, NULL);
}
for (p = self->drivers; p; p = p->drv_next)
{
#if 1 /* start dongshu */
if(p->processed_limit !=0 &&
((p->processed_messages > 0) && (p->processed_messages % p->processed_limit == 0))){
p->flush = TRUE;
}
#endif /* end */
if ((path_flags & PF_FLOW_CTL_OFF) == 0)
log_msg_ack_block_inc(msg);
log_pipe_queue(&p->super, log_msg_ref(msg), path_flags); /* call affile_dd_queue()... */
p->processed_messages++;
}
(*self->processed_messages)++;
if ((path_flags & PF_FLOW_CTL_OFF) == 0)
log_msg_ack(msg);
log_msg_unref(msg);
}
void
test_rule_action_message_tag(const gchar *pattern, gint timeout, gint ndx, const gchar *tag, gboolean set)
{
LogMessage *msg = log_msg_new_empty();
gboolean found, result;
PDBInput input;
log_msg_set_value(msg, LM_V_MESSAGE, pattern, strlen(pattern));
log_msg_set_value(msg, LM_V_PROGRAM, "prog2", 5);
log_msg_set_value(msg, LM_V_HOST, MYHOST, strlen(MYHOST));
log_msg_set_value(msg, LM_V_PID, MYPID, strlen(MYPID));
msg->timestamps[LM_TS_STAMP].tv_sec = msg->timestamps[LM_TS_RECVD].tv_sec;
result = pattern_db_process(patterndb, PDB_INPUT_WRAP_MESSAGE(&input, msg));
if (timeout)
timer_wheel_set_time(patterndb->timer_wheel, timer_wheel_get_time(patterndb->timer_wheel) + timeout + 5);
if (ndx >= messages->len)
{
test_fail("Expected the %d. message, but no such message was returned by patterndb\n", ndx);
goto exit;
}
found = log_msg_is_tag_by_name((LogMessage *) g_ptr_array_index(messages, ndx), tag);
if (set ^ found)
test_fail("Tag '%s' is %sset for pattern '%s' (%d), index %d\n", tag, found ? "" : "not ", pattern, !!result, ndx);
exit:
log_msg_unref(msg);
test_clean_state();
}
static void
_push_tail(LogQueue *s, LogMessage *msg, const LogPathOptions *path_options)
{
LogQueueDisk *self = (LogQueueDisk *) s;
LogPathOptions local_options = *path_options;
g_static_mutex_lock(&self->super.lock);
if (self->push_tail)
{
if (self->push_tail(self, msg, &local_options, path_options))
{
log_queue_push_notify (&self->super);
stats_counter_inc(self->super.stored_messages);
log_msg_ack(msg, &local_options, AT_PROCESSED);
log_msg_unref(msg);
g_static_mutex_unlock(&self->super.lock);
return;
}
}
stats_counter_inc (self->super.dropped_messages);
if (path_options->flow_control_requested)
log_msg_ack(msg, path_options, AT_SUSPENDED);
else
log_msg_drop(msg, path_options, AT_PROCESSED);
g_static_mutex_unlock(&self->super.lock);
}
/*
* Can only run from the output thread.
*/
static void
log_queue_fifo_ack_backlog(LogQueue *s, gint n)
{
LogQueueFifo *self = (LogQueueFifo *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gint i;
log_queue_assert_output_thread(s);
for (i = 0; i < n && self->qbacklog_len > 0; i++)
{
LogMessageQueueNode *node;
node = iv_list_entry(self->qbacklog.next, LogMessageQueueNode, list);
msg = node->msg;
path_options.ack_needed = node->ack_needed;
iv_list_del(&node->list);
log_msg_free_queue_node(node);
self->qbacklog_len--;
log_msg_ack(msg, &path_options);
log_msg_unref(msg);
}
}
static void
afinet_dd_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options, gpointer user_data)
{
#if SYSLOG_NG_ENABLE_SPOOF_SOURCE
AFInetDestDriver *self = (AFInetDestDriver *) s;
/* NOTE: this code should probably become a LogTransport instance so that
* spoofed packets are also going through the LogWriter queue */
if (self->spoof_source && self->lnet_ctx && msg->saddr && (msg->saddr->sa.sa_family == AF_INET || msg->saddr->sa.sa_family == AF_INET6) && log_writer_opened(self->super.writer))
{
gboolean success = FALSE;
g_assert(self->super.transport_mapper->sock_type == SOCK_DGRAM);
g_static_mutex_lock(&self->lnet_lock);
if (!self->lnet_buffer)
self->lnet_buffer = g_string_sized_new(self->spoof_source_maxmsglen);
log_writer_format_log(self->super.writer, msg, self->lnet_buffer);
if (self->lnet_buffer->len > self->spoof_source_maxmsglen)
g_string_truncate(self->lnet_buffer, self->spoof_source_maxmsglen);
switch (self->super.dest_addr->sa.sa_family)
{
case AF_INET:
success = afinet_dd_construct_ipv4_packet(self, msg, self->lnet_buffer);
break;
#if SYSLOG_NG_ENABLE_IPV6
case AF_INET6:
success = afinet_dd_construct_ipv6_packet(self, msg, self->lnet_buffer);
break;
#endif
default:
g_assert_not_reached();
}
if (success)
{
if (libnet_write(self->lnet_ctx) >= 0)
{
/* we have finished processing msg */
log_msg_ack(msg, path_options, AT_PROCESSED);
log_msg_unref(msg);
g_static_mutex_unlock(&self->lnet_lock);
return;
}
else
{
msg_error("Error sending raw frame",
evt_tag_str("error", libnet_geterror(self->lnet_ctx)));
}
}
g_static_mutex_unlock(&self->lnet_lock);
}
#endif
log_dest_driver_queue_method(s, msg, path_options, user_data);
}
static gboolean
afamqp_worker_insert(LogThrDestDriver *s)
{
AMQPDestDriver *self = (AMQPDestDriver *)s;
gboolean success;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
afamqp_dd_connect(self, TRUE);
success = log_queue_pop_head(s->queue, &msg, &path_options, FALSE, FALSE);
if (!success)
return TRUE;
msg_set_context(msg);
success = afamqp_worker_publish (self, msg);
msg_set_context(NULL);
if (success)
{
stats_counter_inc(s->stored_messages);
step_sequence_number(&self->seq_num);
log_msg_ack(msg, &path_options);
log_msg_unref(msg);
}
else
log_queue_push_head(s->queue, msg, &path_options);
return success;
}
void
pdb_context_unref(PDBContext *self)
{
gint i;
if (--self->ref_cnt == 0)
{
for (i = 0; i < self->messages->len; i++)
{
log_msg_unref((LogMessage *) g_ptr_array_index(self->messages, i));
}
g_ptr_array_free(self->messages, TRUE);
if (self->rule)
pdb_rule_unref(self->rule);
if (self->key.host)
g_free((gchar *) self->key.host);
if (self->key.program)
g_free((gchar *) self->key.program);
if (self->key.pid)
g_free((gchar *) self->key.pid);
g_free(self->key.session_id);
g_free(self);
}
}
void
test_filters(gboolean not)
{
LogMessage *msg = log_msg_new_empty();
FilterExprNode *f = filter_tags_new(NULL);
guint i;
GList *l = NULL;
test_msg("=== filter tests %s===\n", not ? "not " : "");
for (i = 1; i < FILTER_TAGS; i += 3)
l = g_list_prepend(l, get_tag_by_id(i));
filter_tags_add(f, l);
f->comp = not;
for (i = 0; i < FILTER_TAGS; i++)
{
test_msg("Testing filter, message has tag %d\n", i);
log_msg_set_tag_by_id(msg, i);
if (((i % 3 == 1) ^ filter_expr_eval(f, msg)) ^ not)
test_fail("Failed to match message by tag %d\n", i);
test_msg("Testing filter, message no tag\n");
log_msg_clear_tag_by_id(msg, i);
if (filter_expr_eval(f, msg) ^ not)
test_fail("Failed to match message with no tags\n");
}
filter_expr_unref(f);
log_msg_unref(msg);
}
void
log_threaded_dest_driver_message_rewind(LogThrDestDriver *self,
LogMessage *msg)
{
log_queue_rewind_backlog(self->queue, 1);
log_msg_unref(msg);
}
void
test_kmsg_device_parsing(void)
{
gchar msg_subsys[] = "6,202,98513;pci_root PNP0A08:00: host bridge window [io 0x0000-0x0cf7]\n" \
" SUBSYSTEM=acpi\n" \
" DEVICE=+acpi:PNP0A08:00\n";
gchar msg_block[] = "6,202,98513;Fake message\n" \
" DEVICE=b12:1\n";
gchar msg_char[] = "6,202,98513;Fake message\n" \
" DEVICE=c3:4\n";
gchar msg_netdev[] = "6,202,98513;Fake message\n" \
" DEVICE=n8\n";
gchar msg_unknown[] = "6,202,98513;Fake message\n" \
" DEVICE=w12345\n";
LogMessage *parsed_message;
testcase_begin("Testing /dev/kmsg DEVICE= parsing");
parsed_message = kmsg_parse_message(msg_subsys);
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.type", "acpi");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.name", "PNP0A08:00");
log_msg_unref(parsed_message);
parsed_message = kmsg_parse_message(msg_block);
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.type", "block");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.major", "12");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.minor", "1");
log_msg_unref(parsed_message);
parsed_message = kmsg_parse_message(msg_char);
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.type", "char");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.major", "3");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.minor", "4");
log_msg_unref(parsed_message);
parsed_message = kmsg_parse_message(msg_netdev);
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.type", "netdev");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.index", "8");
log_msg_unref(parsed_message);
parsed_message = kmsg_parse_message(msg_unknown);
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.type", "<unknown>");
assert_log_kmsg_value(parsed_message, ".linux.DEVICE.name", "w12345");
log_msg_unref(parsed_message);
testcase_end();
}
/**
* afsql_dd_insert_db:
*
* This function is running in the database thread
*
* Returns: FALSE to indicate that the connection should be closed and
* this destination suspended for time_reopen() time.
**/
static gboolean
afsql_dd_insert_db(AFSqlDestDriver *self)
{
GString *table, *query_string;
LogMessage *msg;
gboolean success;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
afsql_dd_connect(self);
success = log_queue_pop_head(self->queue, &msg, &path_options, (self->flags & AFSQL_DDF_EXPLICIT_COMMITS), FALSE);
if (!success)
return TRUE;
msg_set_context(msg);
table = afsql_dd_validate_table(self, msg);
if (!table)
{
/* If validate table is FALSE then close the connection and wait time_reopen time (next call) */
msg_error("Error checking table, disconnecting from database, trying again shortly",
evt_tag_int("time_reopen", self->time_reopen),
NULL);
msg_set_context(NULL);
g_string_free(table, TRUE);
return afsql_dd_insert_fail_handler(self, msg, &path_options);
}
query_string = afsql_dd_construct_query(self, table, msg);
if (self->flush_lines_queued == 0 && !afsql_dd_begin_txn(self))
return FALSE;
success = afsql_dd_run_query(self, query_string->str, FALSE, NULL);
if (success && self->flush_lines_queued != -1)
{
self->flush_lines_queued++;
if (self->flush_lines && self->flush_lines_queued == self->flush_lines && !afsql_dd_commit_txn(self))
return FALSE;
}
g_string_free(table, TRUE);
g_string_free(query_string, TRUE);
msg_set_context(NULL);
if (!success)
return afsql_dd_insert_fail_handler(self, msg, &path_options);
/* we only ACK if each INSERT is a separate transaction */
if ((self->flags & AFSQL_DDF_EXPLICIT_COMMITS) == 0)
log_msg_ack(msg, &path_options);
log_msg_unref(msg);
step_sequence_number(&self->seq_num);
self->failed_message_counter = 0;
return TRUE;
}
void
msg_post_message(LogMessage *msg)
{
if (msg_post_func)
msg_post_func(msg);
else
log_msg_unref(msg);
}
/*
* NOTE: suppress_lock must be held.
*/
static void
log_writer_release_last_message(LogWriter *self)
{
if (self->last_msg)
log_msg_unref(self->last_msg);
self->last_msg = NULL;
self->last_msg_count = 0;
}
static void
early_ack_tracker_manage_msg_ack(AckTracker *s, LogMessage *msg, AckType ack_type)
{
EarlyAckTracker *self = (EarlyAckTracker *)s;
log_source_flow_control_adjust(self->super.source, 1);
log_msg_unref(msg);
log_pipe_unref((LogPipe *)self->super.source);
}
static int
lua_message_metatable__gc(lua_State *state)
{
LogMessage *m = lua_check_and_convert_userdata(state, 1, LUA_MESSAGE_TYPE);
log_msg_unref(m);
return 0;
};
void
log_threaded_dest_driver_message_accept(LogThrDestDriver *self,
LogMessage *msg)
{
self->retries.counter = 0;
step_sequence_number(&self->seq_num);
log_queue_ack_backlog(self->queue, 1);
log_msg_unref(msg);
}
static void
_execute_action_message(PatternDB *db, PDBProcessParams *process_params)
{
LogMessage *genmsg;
genmsg = _generate_synthetic_message(process_params);
_emit_message(db, process_params, TRUE, genmsg);
log_msg_unref(genmsg);
}
/*
* NOTE: suppress_lock must be held.
*/
static void
log_writer_last_msg_release(LogWriter *self)
{
log_writer_update_suppress_timer(self, 0);
if (self->last_msg)
log_msg_unref(self->last_msg);
self->last_msg = NULL;
self->last_msg_count = 0;
}
/*
* NOTE: suppress_lock must be held.
*/
static void
log_writer_release_last_message(LogWriter *self)
{
ml_batched_timer_cancel(&self->suppress_timer);
if (self->last_msg)
log_msg_unref(self->last_msg);
self->last_msg = NULL;
self->last_msg_count = 0;
}
/**
* Remember the last message for dup detection.
*
* NOTE: suppress_lock must be held.
**/
static void
log_writer_last_msg_record(LogWriter *self, LogMessage *lm)
{
if (self->last_msg)
log_msg_unref(self->last_msg);
log_msg_ref(lm);
self->last_msg = lm;
self->last_msg_count = 0;
}
void
assert_msg_matches_and_output_message_has_tag_with_timeout(const gchar *pattern, gint timeout, gint ndx, const gchar *tag, gboolean set)
{
LogMessage *msg;
msg = _construct_message("prog2", pattern);
_process(msg);
_advance_time(timeout);
assert_output_message_has_tag(ndx, tag, set);
log_msg_unref(msg);
}