static void
log_reader_work_finished(void *s)
{
LogReader *self = (LogReader *) s;
if (self->pending_proto_present)
{
/* pending proto is only set in the main thread, so no need to
* lock it before coming here. After we're syncing with the
* log_writer_reopen() call, quite possibly coming from a
* non-main thread. */
g_static_mutex_lock(&self->pending_proto_lock);
if (self->proto)
log_proto_server_free(self->proto);
self->proto = self->pending_proto;
self->pending_proto = NULL;
self->pending_proto_present = FALSE;
g_cond_signal(self->pending_proto_cond);
g_static_mutex_unlock(&self->pending_proto_lock);
}
if (self->notify_code)
{
gint notify_code = self->notify_code;
self->notify_code = 0;
log_pipe_notify(self->control, &self->super.super, notify_code, self);
}
if (self->super.super.flags & PIF_INITIALIZED)
{
/* reenable polling the source assuming that we're still in
* business (e.g. the reader hasn't been uninitialized) */
log_proto_server_reset_error(self->proto);
log_reader_start_watches(self);
}
log_pipe_unref(&self->super.super);
}
static void
afsocket_sd_close_connection(AFSocketSourceDriver *self, AFSocketSourceConnection *sc)
{
gchar buf1[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
if (sc->peer_addr->sa.sa_family != AF_UNIX)
msg_notice("Syslog connection closed",
evt_tag_int("fd", sc->sock),
evt_tag_str("client", g_sockaddr_format(sc->peer_addr, buf1, sizeof(buf1), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
NULL);
else
msg_verbose("Syslog connection closed",
evt_tag_int("fd", sc->sock),
evt_tag_str("client", g_sockaddr_format(sc->peer_addr, buf1, sizeof(buf1), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
NULL);
log_pipe_deinit(&sc->super);
log_pipe_unref(&sc->super);
self->num_connections--;
}
void
test_journal_reader()
{
TestSource *src = test_source_new(configuration);
TestCase tc_default_working = { _test_default_working_init, _test_default_working_test, NULL, NULL };
TestCase tc_prefix = { _test_prefix_init, _test_prefix_test, NULL, "this.is.a.prefix." };
TestCase tc_max_field_size = { _test_field_size_init, _test_field_size_test, NULL, GINT_TO_POINTER(10)};
TestCase tc_timezone = { _test_timezone_init, _test_timezone_test, NULL, NULL };
TestCase tc_default_level = { _test_default_level_init, _test_default_level_test, NULL, GINT_TO_POINTER(LOG_ERR) };
TestCase tc_default_facility = { _test_default_facility_init, _test_default_facility_test, NULL, GINT_TO_POINTER(LOG_AUTH) };
test_source_add_test_case(src, &tc_default_working);
test_source_add_test_case(src, &tc_prefix);
test_source_add_test_case(src, &tc_max_field_size);
test_source_add_test_case(src, &tc_timezone);
test_source_add_test_case(src, &tc_default_level);
test_source_add_test_case(src, &tc_default_facility);
test_source_run_tests(src);
log_pipe_unref((LogPipe *)src);
}
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;
if (ack_type == AT_SUSPENDED)
log_source_flow_control_suspend(self->super.source);
late_ack_tracker_lock(s);
{
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_adjust_when_suspended(self->super.source, ack_range_length);
else
log_source_flow_control_adjust(self->super.source, ack_range_length);
if (ring_buffer_is_empty(&self->ack_record_storage))
late_ack_tracker_on_all_acked_call(s);
}
}
late_ack_tracker_unlock(s);
log_msg_unref(msg);
log_pipe_unref((LogPipe *)self->super.source);
}
static LogMessage *
parse_geoip_into_log_message_no_check(const gchar *input)
{
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
LogParser *cloned_parser;
gboolean success;
cloned_parser = (LogParser *) log_pipe_clone(&geoip_parser->super);
log_pipe_init(&cloned_parser->super);
msg = log_msg_new_empty();
log_msg_set_value(msg, LM_V_MESSAGE, input, -1);
success = log_parser_process_message(cloned_parser, &msg, &path_options);
if (!success)
{
log_msg_unref(msg);
msg = NULL;
}
log_pipe_deinit(&cloned_parser->super);
log_pipe_unref(&cloned_parser->super);
return msg;
}
static gboolean
__init(LogPipe *s)
{
SystemdJournalSourceDriver *self = (SystemdJournalSourceDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
self->reader = journal_reader_new(cfg, self->journald);
journal_reader_options_init(&self->reader_options, cfg, self->super.super.group);
journal_reader_set_options((LogPipe *)self->reader, &self->super.super.super, &self->reader_options, 0, SCS_JOURNALD,
self->super.super.id, "journal");
log_pipe_append((LogPipe *)self->reader, &self->super.super.super);
if (!log_pipe_init((LogPipe *)self->reader))
{
msg_error("Error initializing journal_reader");
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
return FALSE;
}
return TRUE;
}
static gboolean
afstreams_sd_deinit(LogPipe *s)
{
AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) s;
if (self->reader)
{
log_pipe_deinit((LogPipe *) self->reader);
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
}
if (self->door_fd != -1)
{
door_revoke(self->door_fd);
close(self->door_fd);
}
if (!log_src_driver_deinit_method(s))
return FALSE;
return TRUE;
}
void
_create_file_reader(WildcardSourceDriver *self, const gchar *full_path)
{
WildcardFileReader *reader = NULL;
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
if (g_hash_table_size(self->file_readers) >= self->max_files)
{
msg_warning("Number of allowed monitorod file is reached, rejecting read file",
evt_tag_str("source", self->super.super.group),
evt_tag_str("filename", full_path),
evt_tag_int("max_files", self->max_files));
pending_file_list_add(self->waiting_list, full_path);
return;
}
reader = wildcard_file_reader_new(full_path,
&self->file_reader_options,
self->file_opener,
&self->super,
cfg);
wildcard_file_reader_on_deleted_file_finished(reader, _remove_file_reader, self);
wildcard_file_reader_on_deleted_file_eof(reader, _stop_file_reader, self);
log_pipe_append(&reader->super.super, &self->super.super.super);
if (!log_pipe_init(&reader->super.super))
{
msg_warning("File reader initialization failed",
evt_tag_str("filename", full_path),
evt_tag_str("source_driver", self->super.super.group));
log_pipe_unref(&reader->super.super);
}
else
{
g_hash_table_insert(self->file_readers, g_strdup(full_path), reader);
}
}
static void
_remove_file_reader(FileReader *reader, gpointer user_data)
{
WildcardSourceDriver *self = (WildcardSourceDriver *) user_data;
_deleted_cb(reader, user_data);
log_pipe_ref(&reader->super);
if (g_hash_table_remove(self->file_readers, reader->filename->str))
{
msg_debug("File is removed from the file list", evt_tag_str("Filename", reader->filename->str));
}
else
{
msg_error("Can't remove the file reader", evt_tag_str("Filename", reader->filename->str));
}
log_pipe_unref(&reader->super);
gchar *full_path = pending_file_list_pop(self->waiting_list);
if (full_path)
{
_create_file_reader(self, full_path);
g_free(full_path);
}
}
Test(date, test_date_with_guess_timezone)
{
const gchar *msg = "2015-12-30T12:00:00+05:00";
GString *res = g_string_sized_new(128);
LogParser *parser = _construct_parser(NULL, NULL, LM_TS_STAMP);
date_parser_process_flag(parser, "guess-timezone");
LogMessage *logmsg = _construct_logmsg(msg);
gboolean success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
cr_assert(success, "failed to parse timestamp, msg=%s", msg);
append_format_unix_time(&logmsg->timestamps[LM_TS_STAMP], res, TS_FMT_ISO, -1, 0);
/* this should fix up the timezone */
cr_assert_str_eq(res->str, "2015-12-30T12:00:00+01:00",
"incorrect date parsed msg=%s result=%s",
msg, res->str);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
g_string_free(res, TRUE);
}
static gboolean
afsocket_sc_init(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
LogTransport *transport;
LogProtoServer *proto;
if (!self->reader)
{
transport = afsocket_sc_construct_transport(self, self->sock);
/* transport_mapper_inet_construct_log_transport() can return NULL on TLS errors */
if (!transport)
return FALSE;
proto = log_proto_server_factory_construct(self->owner->proto_factory, transport, &self->owner->reader_options.proto_options.super);
self->reader = log_reader_new(s->cfg);
log_reader_reopen(self->reader, proto, poll_fd_events_new(self->sock));
log_reader_set_peer_addr(self->reader, self->peer_addr);
}
log_reader_set_options(self->reader, s,
&self->owner->reader_options,
STATS_LEVEL1,
self->owner->transport_mapper->stats_source,
self->owner->super.super.id,
afsocket_sc_stats_instance(self));
log_pipe_append((LogPipe *) self->reader, s);
if (log_pipe_init((LogPipe *) self->reader))
{
return TRUE;
}
else
{
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
}
return FALSE;
}
static void
affile_sd_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
switch (notify_code)
{
case NC_FILE_MOVED:
{
msg_verbose("Follow-mode file source moved, tracking of the new file is started",
evt_tag_str("filename", self->filename->str),
NULL);
log_pipe_deinit(self->reader);
log_pipe_unref(self->reader);
if (affile_sd_open_file(self, self->filename->str, &fd))
{
LogTransport *transport;
transport = log_transport_plain_new(fd, self->filename, NULL, 0);
transport->timeout = 10;
self->reader = log_reader_new(
log_proto_plain_new_server(transport, self->reader_options.padding,
self->reader_options.msg_size,
((self->reader_options.follow_freq > 0)
? LPPF_IGNORE_EOF
: LPPF_NOMREAD)
),
LR_LOCAL);
log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_FILE, self->super.id, self->filename->str);
log_reader_set_follow_filename(self->reader, self->filename->str);
log_reader_set_immediate_check(self->reader);
log_pipe_append(self->reader, s);
if (!log_pipe_init(self->reader, cfg))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd),
NULL);
log_pipe_unref(self->reader);
self->reader = NULL;
close(fd);
}
}
else
{
self->reader = NULL;
}
break;
}
default:
break;
}
}
static void
destroy_parser(LogParser *snmptrapd_parser)
{
log_pipe_deinit((LogPipe *)snmptrapd_parser);
log_pipe_unref((LogPipe *)snmptrapd_parser);
}
static void
afsocket_sd_kill_connection(AFSocketSourceConnection *sc)
{
log_pipe_deinit(&sc->super);
log_pipe_unref(&sc->super);
}
int
testcase(gchar *msg, guint parse_flags, gint max_columns, guint32 flags, gchar *delimiters, gchar *quotes, gchar *null_value, gchar *first_value, ...)
{
LogMessage *logmsg;
LogColumnParser *p;
gchar *expected_value;
gint i;
va_list va;
NVTable *nvtable;
const gchar *column_array[] =
{
"C1",
"C2",
"C3",
"C4",
"C5",
"C6",
"C7",
"C8",
"C9",
"C10",
"C11",
"C12",
"C13",
"C14",
"C15",
"C16",
"C17",
"C18",
"C19",
"C20",
"C21",
"C22",
"C23",
"C24",
"C25",
"C26",
"C27",
"C28",
"C29",
"C30",
NULL
};
gboolean success;
if (max_columns != -1)
{
g_assert(max_columns < (sizeof(column_array) / sizeof(column_array[0])));
column_array[max_columns] = NULL;
}
parse_options.flags = parse_flags;
logmsg = log_msg_new(msg, strlen(msg), NULL, &parse_options);
p = log_csv_parser_new();
log_csv_parser_set_flags(p, flags);
log_column_parser_set_columns(p, string_array_to_list(column_array));
if (delimiters)
log_csv_parser_set_delimiters(p, delimiters);
if (quotes)
log_csv_parser_set_quote_pairs(p, quotes);
if (null_value)
log_csv_parser_set_null_value(p, null_value);
nvtable = nv_table_ref(logmsg->payload);
success = log_parser_process(&p->super, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
nv_table_unref(nvtable);
if (success && !first_value)
{
fprintf(stderr, "unexpected match; msg=%s\n", msg);
exit(1);
}
if (!success && first_value)
{
fprintf(stderr, "unexpected non-match; msg=%s\n", msg);
exit(1);
}
log_pipe_unref(&p->super.super);
va_start(va, first_value);
expected_value = first_value;
i = 0;
while (expected_value && column_array[i])
{
const gchar *value;
gssize value_len;
value = log_msg_get_value(logmsg, log_msg_get_value_handle(column_array[i]), &value_len);
if (expected_value && expected_value[0])
{
TEST_ASSERT(value && value[0], "expected value set, but no actual value");
TEST_ASSERT(strlen(expected_value) == value_len, "value length doesn't match actual length");
TEST_ASSERT(strncmp(value, expected_value, value_len) == 0, "value does not match expected value");
}
else
{
TEST_ASSERT(!(value && value[0]), "expected unset, but actual value present");
}
expected_value = va_arg(va, char *);
i++;
}
log_msg_unref(logmsg);
return 1;
}
void
setup(void)
{
app_startup();
setlocale (LC_ALL, "C");
setenv("TZ", "CET-1", TRUE);
tzset();
configuration = cfg_new_snippet();
/* year heuristics depends on the current time */
/* Dec 30 2015 */
GTimeVal faked_time =
{
.tv_sec = 1451473200,
.tv_usec = 0
};
set_cached_time(&faked_time);
}
void
teardown(void)
{
app_shutdown();
}
TestSuite(date, .init = setup, .fini = teardown);
ParameterizedTestParameters(date, test_date_parser)
{
static struct date_params params[] =
{
{ "2015-01-26T16:14:49+03:00", NULL, NULL, LM_TS_RECVD, "2015-01-26T16:14:49+03:00" },
/* Various ISO8601 formats */
{ "2015-01-26T16:14:49+0300", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:00" },
{ "2015-01-26T16:14:49+0330", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:30" },
{ "2015-01-26T16:14:49+0200", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+02:00" },
{ "2015-01-26T16:14:49+03:00", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:00" },
{ "2015-01-26T16:14:49+03:30", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:30" },
{ "2015-01-26T16:14:49+02:00", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+02:00" },
{ "2015-01-26T16:14:49Z", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+00:00" },
{ "2015-01-26T16:14:49A", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49-01:00" },
{ "2015-01-26T16:14:49B", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49-02:00" },
{ "2015-01-26T16:14:49N", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+01:00" },
{ "2015-01-26T16:14:49O", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+02:00" },
{ "2015-01-26T16:14:49GMT", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+00:00" },
{ "2015-01-26T16:14:49PDT", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49-07:00" },
/* RFC 2822 */
{ "Tue, 27 Jan 2015 11:48:46 +0200", NULL, "%a, %d %b %Y %T %z", LM_TS_STAMP, "2015-01-27T11:48:46+02:00" },
/* Apache-like */
{ "21/Jan/2015:14:40:07 +0500", NULL, "%d/%b/%Y:%T %z", LM_TS_STAMP, "2015-01-21T14:40:07+05:00" },
/* Dates without timezones. America/Phoenix has no DST */
{ "Tue, 27 Jan 2015 11:48:46", NULL, "%a, %d %b %Y %T", LM_TS_STAMP, "2015-01-27T11:48:46+01:00" },
{ "Tue, 27 Jan 2015 11:48:46", "America/Phoenix", "%a, %d %b %Y %T", LM_TS_STAMP, "2015-01-27T11:48:46-07:00" },
{ "Tue, 27 Jan 2015 11:48:46", "+05:00", "%a, %d %b %Y %T", LM_TS_STAMP, "2015-01-27T11:48:46+05:00" },
/* Try without the year. */
{ "01/Jan:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2016-01-01T00:40:07+05:00" },
{ "01/Aug:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-08-01T00:40:07+05:00" },
{ "01/Sep:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-09-01T00:40:07+05:00" },
{ "01/Oct:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-10-01T00:40:07+05:00" },
{ "01/Nov:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-11-01T00:40:07+05:00" },
{ "1446128356 +01:00", NULL, "%s %z", LM_TS_STAMP, "2015-10-29T15:19:16+01:00" },
{ "1446128356", "Europe/Budapest", "%s", LM_TS_STAMP, "2015-10-29T15:19:16+01:00" },
};
return cr_make_param_array(struct date_params, params, sizeof(params) / sizeof(struct date_params));
}
ParameterizedTest(struct date_params *params, date, test_date_parser)
{
LogMessage *logmsg;
LogParser *parser = _construct_parser(params->timezone_, params->format, params->time_stamp);
gboolean success;
GString *res = g_string_sized_new(128);
logmsg = _construct_logmsg(params->msg);
success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
cr_assert(success, "unable to parse format=%s msg=%s", params->format, params->msg);
append_format_unix_time(&logmsg->timestamps[params->time_stamp], res, TS_FMT_ISO, -1, 0);
cr_assert_str_eq(res->str, params->expected,
"incorrect date parsed msg=%s format=%s, result=%s, expected=%s",
params->msg, params->format, res->str, params->expected);
g_string_free(res, TRUE);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
}
static gboolean
afstreams_sd_init(LogPipe *s)
{
AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
if (!log_src_driver_init_method(s))
return FALSE;
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
fd = open(self->dev_filename->str, O_RDONLY | O_NOCTTY | O_NONBLOCK);
if (fd != -1)
{
struct strioctl ioc;
g_fd_set_cloexec(fd, TRUE);
memset(&ioc, 0, sizeof(ioc));
ioc.ic_cmd = I_CONSLOG;
if (ioctl(fd, I_STR, &ioc) < 0)
{
msg_error("Error in ioctl(I_STR, I_CONSLOG)",
evt_tag_str(EVT_TAG_FILENAME, self->dev_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno));
close(fd);
return FALSE;
}
g_fd_set_nonblock(fd, TRUE);
self->reader = log_reader_new(cfg);
log_reader_reopen(self->reader, log_proto_dgram_server_new(log_transport_streams_new(fd), &self->reader_options.proto_options.super), poll_fd_events_new(fd));
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL1,
SCS_SUN_STREAMS,
self->super.super.id,
self->dev_filename->str);
log_pipe_append((LogPipe *) self->reader, s);
if (self->door_filename)
{
/* door creation is deferred, because it creates threads which is
* not inherited through forks, and syslog-ng forks during
* startup, but _after_ the configuration was initialized */
register_application_hook(AH_POST_DAEMONIZED, afstreams_init_door, self);
}
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd));
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
}
else
{
msg_error("Error opening syslog device",
evt_tag_str(EVT_TAG_FILENAME, self->dev_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno));
return FALSE;
}
return TRUE;
}
static void
perftest_parser(LogParser *p, const gchar *input)
{
iterate_pattern(p, input);
log_pipe_unref(&p->super);
}
static gboolean
afsocket_sc_init(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
gint read_flags;
LogTransport *transport;
LogProto *proto;
read_flags = ((self->owner->flags & AFSOCKET_DGRAM) ? LTF_RECV : 0);
if (!self->reader)
{
#if ENABLE_SSL
if (self->owner->tls_context)
{
TLSSession *tls_session = tls_context_setup_session(self->owner->tls_context);
if (!tls_session)
return FALSE;
transport = log_transport_tls_new(tls_session, self->sock, read_flags);
}
else
#endif
transport = log_transport_plain_new(self->sock, read_flags);
if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
{
/* plain protocol */
if (self->owner->flags & AFSOCKET_DGRAM)
proto = log_proto_dgram_server_new(transport, self->owner->reader_options.msg_size, 0);
else if (self->owner->reader_options.padding)
proto = log_proto_record_server_new(transport, self->owner->reader_options.padding, 0);
else
proto = log_proto_text_server_new(transport, self->owner->reader_options.msg_size, 0);
}
else
{
if (self->owner->flags & AFSOCKET_DGRAM)
{
/* plain protocol */
proto = log_proto_dgram_server_new(transport, self->owner->reader_options.msg_size, 0);
}
else
{
/* framed protocol */
proto = log_proto_framed_server_new(transport, self->owner->reader_options.msg_size);
}
}
self->reader = log_reader_new(proto);
}
log_reader_set_options(self->reader, s, &self->owner->reader_options, 1, afsocket_sc_stats_source(self), self->owner->super.super.id, afsocket_sc_stats_instance(self));
log_reader_set_peer_addr(self->reader, self->peer_addr);
log_pipe_append(self->reader, s);
if (log_pipe_init(self->reader, NULL))
{
return TRUE;
}
else
{
log_pipe_unref(self->reader);
self->reader = NULL;
}
return FALSE;
}
static inline void
afprogram_reload_store_item_free(AFProgramReloadStoreItem *reload_info)
{
log_pipe_unref((LogPipe *)reload_info->writer);
g_free(reload_info);
}
static gboolean
affile_sd_init(LogPipe *s)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
gboolean file_opened, open_deferred = FALSE;
log_reader_options_init(&self->reader_options, cfg, self->super.group);
file_opened = affile_sd_open_file(self, self->filename->str, &fd);
if (!file_opened && self->reader_options.follow_freq > 0)
{
msg_info("Follow-mode file source not found, deferring open",
evt_tag_str("filename", self->filename->str),
NULL);
open_deferred = TRUE;
fd = -1;
}
if (file_opened || open_deferred)
{
LogTransport *transport;
transport = log_transport_plain_new(fd, self->filename, NULL, 0);
transport->timeout = 10;
/* FIXME: we shouldn't use reader_options to store log protocol parameters */
self->reader = log_reader_new(
log_proto_plain_new_server(transport, self->reader_options.padding,
self->reader_options.msg_size,
((self->reader_options.follow_freq > 0)
? LPPF_IGNORE_EOF
: LPPF_NOMREAD)
),
LR_LOCAL);
log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_FILE, self->super.id, self->filename->str);
log_reader_set_follow_filename(self->reader, self->filename->str);
/* NOTE: if the file could not be opened, we ignore the last
* remembered file position, if the file is created in the future
* we're going to read from the start. */
affile_sd_load_pos(s, cfg);
log_pipe_append(self->reader, s);
if (!log_pipe_init(self->reader, NULL))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd),
NULL);
log_pipe_unref(self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
}
else
{
msg_error("Error opening file for reading",
evt_tag_str("filename", self->filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return self->super.optional;
}
return TRUE;
}
static gboolean
affile_sd_init(LogPipe *s)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
gboolean file_opened, open_deferred = FALSE;
if (!log_src_driver_init_method(s))
return FALSE;
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
if ((self->multi_line_mode != MLM_PREFIX_GARBAGE && self->multi_line_mode != MLM_PREFIX_SUFFIX ) && (self->multi_line_prefix || self->multi_line_garbage))
{
msg_error("multi-line-prefix() and/or multi-line-garbage() specified but multi-line-mode() is not regexp based (prefix-garbage or prefix-suffix), please set multi-line-mode() properly", NULL);
return FALSE;
}
file_opened = affile_sd_open_file(self, self->filename->str, &fd);
if (!file_opened && self->follow_freq > 0)
{
msg_info("Follow-mode file source not found, deferring open",
evt_tag_str("filename", self->filename->str),
NULL);
open_deferred = TRUE;
fd = -1;
}
if (file_opened || open_deferred)
{
LogProtoServer *proto;
PollEvents *poll_events;
poll_events = affile_sd_construct_poll_events(self, fd);
if (!poll_events)
{
close(fd);
return FALSE;
}
proto = affile_sd_construct_proto(self, fd);
self->reader = log_reader_new(self->super.super.super.cfg);
log_reader_reopen(self->reader, proto, poll_events);
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL1,
SCS_FILE,
self->super.super.id,
self->filename->str);
/* NOTE: if the file could not be opened, we ignore the last
* remembered file position, if the file is created in the future
* we're going to read from the start. */
log_pipe_append((LogPipe *) self->reader, s);
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd),
NULL);
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
affile_sd_recover_state(s, cfg, proto);
}
else
{
msg_error("Error opening file for reading",
evt_tag_str("filename", self->filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return self->super.super.optional;
}
return TRUE;
}
static gboolean
afsocket_sc_init(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
gint read_flags;
LogTransport *transport;
LogProto *proto;
read_flags = ((self->owner->flags & AFSOCKET_DGRAM) ? LTF_RECV : 0);
#if ENABLE_SSL
if (self->owner->tls_context)
{
TLSSession *tls_session = tls_context_setup_session(self->owner->tls_context);
if (!tls_session)
return FALSE;
transport = log_transport_tls_new(tls_session, self->sock, read_flags);
}
else
#endif
transport = log_transport_plain_new(self->sock, read_flags);
if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
{
/* plain protocol */
proto = log_proto_plain_new_server(transport, self->owner->reader_options.padding,
self->owner->reader_options.msg_size,
(self->owner->flags & AFSOCKET_DGRAM) ? (LPPF_PKTTERM + LPPF_IGNORE_EOF) : 0);
}
else
{
if (self->owner->flags & AFSOCKET_DGRAM)
{
/* plain protocol */
proto = log_proto_plain_new_server(transport, self->owner->reader_options.padding,
self->owner->reader_options.msg_size,
(self->owner->flags & AFSOCKET_DGRAM) ? (LPPF_PKTTERM + LPPF_IGNORE_EOF) : 0);
}
else
{
/* framed protocol */
proto = log_proto_framed_new_server(transport, self->owner->reader_options.msg_size);
}
}
self->reader = log_reader_new(proto,
((self->owner->flags & AFSOCKET_LOCAL) ? LR_LOCAL : 0) |
((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) ? LR_SYSLOG_PROTOCOL : 0));
log_reader_set_options(self->reader, s, &self->owner->reader_options, 1, afsocket_sc_stats_source(self), self->owner->super.id, afsocket_sc_stats_instance(self));
log_reader_set_peer_addr(self->reader, self->peer_addr);
log_pipe_append(self->reader, s);
if (log_pipe_init(self->reader, NULL))
{
self->owner->connections = g_list_prepend(self->owner->connections, self);
return TRUE;
}
else
{
log_pipe_unref(self->reader);
self->reader = NULL;
}
return FALSE;
}
