static void
_handle_file_created(WildcardSourceDriver *self, const DirectoryMonitorEvent *event)
{
if (g_pattern_match_string(self->compiled_pattern, event->name))
{
WildcardFileReader *reader = g_hash_table_lookup(self->file_readers, event->full_path);
if (!reader)
{
_create_file_reader(self, event->full_path);
msg_debug("Wildcard: file created", evt_tag_str("filename", event->full_path));
}
else
{
if (wildcard_file_reader_is_deleted(reader))
{
msg_info("File is deleted, new file create with same name. "
"While old file is reading, skip the new one",
evt_tag_str("filename", event->full_path));
pending_file_list_add(self->waiting_list, event->full_path);
}
else if (!log_pipe_init(&reader->super.super))
{
msg_error("Can not re-initialize reader for file",
evt_tag_str("filename", event->full_path));
}
else
{
msg_debug("Wildcard: file reader reinitialized", evt_tag_str("filename", event->full_path));
}
}
}
}
static gboolean
afsocket_sc_init(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
LogTransport *transport;
LogProtoServer *proto;
if (!self->reader)
{
transport = afsocket_sd_construct_transport(self->owner, self->sock);
proto = log_proto_server_factory_construct(self->owner->proto_factory, transport, &self->owner->reader_options.proto_options.super);
self->reader = log_reader_new(proto);
}
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_reader_set_peer_addr(self->reader, self->peer_addr);
log_pipe_append((LogPipe *) self->reader, s);
if (log_pipe_init((LogPipe *) self->reader, NULL))
{
return TRUE;
}
else
{
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
}
return FALSE;
}
static gboolean
afsocket_sd_restore_kept_alive_connections(AFSocketSourceDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
/* fetch persistent connections first */
if (self->connections_kept_alive_accross_reloads)
{
GList *p = NULL;
self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE));
self->num_connections = 0;
for (p = self->connections; p; p = p->next)
{
afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self);
if (log_pipe_init((LogPipe *) p->data))
{
self->num_connections++;
}
else
{
AFSocketSourceConnection *sc = (AFSocketSourceConnection *)p->data;
self->connections = g_list_remove(self->connections, sc);
afsocket_sd_kill_connection((AFSocketSourceConnection *)sc);
}
}
}
return TRUE;
}
/* NOTE: runs in the main thread */
static void
affile_sd_notify(LogPipe *s, 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((LogPipe *) self->reader);
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
if (affile_sd_open_file(self, self->filename->str, &fd))
{
LogProtoServer *proto;
PollEvents *poll_events;
poll_events = affile_sd_construct_poll_events(self, fd);
if (!poll_events)
break;
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);
log_reader_set_immediate_check(self->reader);
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);
}
affile_sd_recover_state(s, cfg, proto);
}
break;
}
default:
break;
}
}
static void
_setup_dd(void)
{
dd = test_threaded_dd_new(main_loop_get_current_config(main_loop));
cr_assert(log_pipe_init(&dd->super.super.super.super));
}
static gboolean
afprogram_dd_init(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
log_writer_options_init(&self->writer_options, cfg, 0);
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_FILE);
log_writer_set_options(self->writer,
s,
&self->writer_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->cmdline->str);
log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afprogram_dd_format_persist_name(self)));
log_pipe_init((LogPipe *) self->writer, NULL);
log_pipe_append(&self->super.super.super, (LogPipe *) self->writer);
return afprogram_dd_reopen(self);
}
static gboolean
afprogram_dd_init(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
log_writer_options_init(&self->writer_options, cfg, 0);
const gboolean restore_successful = afprogram_dd_restore_reload_store_item(self, cfg);
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_FILE, s->cfg);
log_writer_set_options(self->writer,
s,
&self->writer_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->process_info.cmdline->str);
log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super,
afprogram_dd_format_queue_persist_name(self)));
if (!log_pipe_init((LogPipe *) self->writer))
{
log_pipe_unref((LogPipe *) self->writer);
return FALSE;
}
log_pipe_append(&self->super.super.super, (LogPipe *) self->writer);
return restore_successful ? TRUE : afprogram_dd_reopen(self);
}
static gboolean
log_source_group_init(LogPipe *s)
{
LogSourceGroup *self = (LogSourceGroup *) s;
LogDriver *p;
GlobalConfig *cfg = log_pipe_get_config(s);
gint id = 0;
for (p = self->drivers; p; p = p->drv_next)
{
p->group = g_strdup(self->name);
if (!p->id)
p->id = g_strdup_printf("%s#%d", self->name, id++);
if (!log_pipe_init(&p->super, cfg))
{
msg_error("Error initializing source driver",
evt_tag_str("source", self->name),
evt_tag_str("id", p->id),
NULL);
goto deinit_all;
}
log_pipe_append(&p->super, s);
}
stats_register_counter(0, SCS_SOURCE | SCS_GROUP, self->name, NULL, SC_TYPE_PROCESSED, &self->processed_messages);
return TRUE;
deinit_all:
for (p = self->drivers; p; p = p->drv_next)
log_pipe_deinit(&p->super);
return FALSE;
}
static gboolean
afsocket_dd_setup_writer(AFSocketDestDriver *self)
{
afsocket_dd_restore_writer(self);
if (!self->writer)
{
/* NOTE: we open our writer with no fd, so we can send messages down there
* even while the connection is not established */
self->writer = afsocket_dd_construct_writer(self);
}
log_writer_set_options(self->writer, &self->super.super.super,
&self->writer_options,
STATS_LEVEL0,
self->transport_mapper->stats_source,
self->super.super.id,
afsocket_dd_stats_instance(self));
log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(
&self->super, afsocket_dd_format_qfile_name(self)));
if (!log_pipe_init((LogPipe *) self->writer))
{
log_pipe_unref((LogPipe *) self->writer);
return FALSE;
}
log_pipe_append(&self->super.super.super, (LogPipe *) self->writer);
return TRUE;
}
static gboolean
afsocket_sd_process_connection(AFSocketSourceDriver *self, GSockAddr *client_addr, GSockAddr *local_addr, gint fd)
{
gchar buf[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
#if SYSLOG_NG_ENABLE_TCP_WRAPPER
if (client_addr && (client_addr->sa.sa_family == AF_INET
#if SYSLOG_NG_ENABLE_IPV6
|| client_addr->sa.sa_family == AF_INET6
#endif
))
{
struct request_info req;
request_init(&req, RQ_DAEMON, "syslog-ng", RQ_FILE, fd, 0);
fromhost(&req);
if (hosts_access(&req) == 0)
{
msg_error("Syslog connection rejected by tcpd",
evt_tag_str("client", g_sockaddr_format(client_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(local_addr, buf2, sizeof(buf2), GSA_FULL)),
NULL);
return FALSE;
}
}
#endif
if (self->num_connections >= self->max_connections)
{
msg_error("Number of allowed concurrent connections reached, rejecting connection",
evt_tag_str("client", g_sockaddr_format(client_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(local_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_int("max", self->max_connections),
NULL);
return FALSE;
}
else
{
AFSocketSourceConnection *conn;
conn = afsocket_sc_new(client_addr, fd, self->super.super.super.cfg);
afsocket_sc_set_owner(conn, self);
if (log_pipe_init(&conn->super))
{
afsocket_sd_add_connection(self, conn);
self->num_connections++;
log_pipe_append(&conn->super, &self->super.super.super);
}
else
{
log_pipe_unref(&conn->super);
return FALSE;
}
}
return TRUE;
}
/* NOTE: runs in the main thread */
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;
LogProto *proto;
transport = log_transport_plain_new(fd, 0);
transport->timeout = 10;
proto = affile_sd_construct_proto(self, transport);
self->reader = log_reader_new(proto);
log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_FILE, self->super.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);
}
affile_sd_recover_state(s, cfg, proto);
}
else
{
self->reader = NULL;
}
break;
}
default:
break;
}
}
static gboolean
afprogram_sd_init(LogPipe *s)
{
AFProgramSourceDriver *self = (AFProgramSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
if (!log_src_driver_init_method(s))
return FALSE;
if (cfg)
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
msg_verbose("Starting source program",
evt_tag_str("cmdline", self->process_info.cmdline->str));
if (!afprogram_popen(&self->process_info, G_IO_IN, &fd))
return FALSE;
/* parent */
child_manager_register(self->process_info.pid, afprogram_sd_exit, log_pipe_ref(&self->super.super.super),
(GDestroyNotify) log_pipe_unref);
g_fd_set_nonblock(fd, TRUE);
g_fd_set_cloexec(fd, TRUE);
if (!self->reader)
{
LogTransport *transport;
transport = log_transport_pipe_new(fd);
self->reader = log_reader_new(s->cfg);
log_reader_reopen(self->reader, log_proto_text_server_new(transport, &self->reader_options.proto_options.super),
poll_fd_events_new(fd));
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->process_info.cmdline->str);
}
log_pipe_append((LogPipe *) self->reader, &self->super.super.super);
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing program source, closing fd",
evt_tag_int("fd", fd));
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
return TRUE;
}
gboolean
afsocket_dd_init(LogPipe *s)
{
AFSocketDestDriver *self = (AFSocketDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
if (!afsocket_dd_apply_transport(self))
return FALSE;
/* these fields must be set up by apply_transport, so let's check if it indeed did */
g_assert(self->transport);
g_assert(self->bind_addr);
g_assert(self->hostname);
g_assert(self->dest_name);
if (cfg)
{
self->time_reopen = cfg->time_reopen;
}
log_writer_options_init(&self->writer_options, cfg, 0);
self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, FALSE));
if (!self->writer)
{
/* NOTE: we open our writer with no fd, so we can send messages down there
* even while the connection is not established */
self->writer = log_writer_new(LW_FORMAT_PROTO |
#if ENABLE_SSL
(((self->flags & AFSOCKET_STREAM) && !self->tls_context) ? LW_DETECT_EOF : 0) |
#else
((self->flags & AFSOCKET_STREAM) ? LW_DETECT_EOF : 0) |
#endif
(self->flags & AFSOCKET_SYSLOG_PROTOCOL ? LW_SYSLOG_PROTOCOL : 0));
}
log_writer_set_options((LogWriter *) self->writer, &self->super.super.super, &self->writer_options, 0, afsocket_dd_stats_source(self), self->super.super.id, afsocket_dd_stats_instance(self));
log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afsocket_dd_format_persist_name(self, TRUE)));
log_pipe_init(self->writer, NULL);
log_pipe_append(&self->super.super.super, self->writer);
if (!log_writer_opened((LogWriter *) self->writer))
afsocket_dd_reconnect(self);
return TRUE;
}
static LogParser *
_construct_parser(gchar *timezone_, gchar *format, gint time_stamp)
{
LogParser *parser;
parser = date_parser_new (configuration);
if (format != NULL)
date_parser_set_format(parser, format);
if (timezone_ != NULL)
date_parser_set_timezone(parser, timezone_);
date_parser_set_time_stamp(parser, time_stamp);
log_pipe_init(&parser->super);
return parser;
}
static LogParser *
create_parser(TestParserOptions *options)
{
LogParser *snmptrapd_parser = snmptrapd_parser_new(configuration);
if (options)
{
if (options->key_prefix)
snmptrapd_parser_set_prefix(snmptrapd_parser, options->key_prefix);
snmptrapd_parser_set_set_message_macro(snmptrapd_parser, options->set_message_macro);
}
log_pipe_init((LogPipe *)snmptrapd_parser);
return snmptrapd_parser;
}
static gboolean
__init(LogPipe *s)
{
TestSource *self = (TestSource *)s;
self->reader = journal_reader_new(configuration, self->journald_mock);
journal_reader_options_defaults(&self->options);
if (self->current_test_case && self->current_test_case->init)
{
self->current_test_case->init(self->current_test_case, self, self->journald_mock, self->reader, &self->options);
}
journal_reader_options_init(&self->options, configuration, "test");
journal_reader_set_options((LogPipe *)self->reader, &self->super, &self->options, 3, SCS_JOURNALD, "test", "1");
log_pipe_append((LogPipe *)self->reader, &self->super);
assert_true(log_pipe_init((LogPipe *)self->reader), ASSERTION_ERROR("Can't initialize reader"));
return TRUE;
}
gboolean
afsocket_dd_init(LogPipe *s)
{
AFSocketDestDriver *self = (AFSocketDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
#if ENABLE_SSL
if (self->flags & AFSOCKET_REQUIRE_TLS && !self->tls_context)
{
msg_error("Transport TLS was specified, but TLS related parameters missing", NULL);
return FALSE;
}
#endif
self->error_logged = FALSE;
if (cfg)
{
self->time_reopen = cfg->time_reopen;
}
if (!self->writer)
{
log_writer_options_init(&self->writer_options, cfg, 0);
/* NOTE: we open our writer with no fd, so we can send messages down there
* even while the connection is not established */
if ((self->flags & AFSOCKET_KEEP_ALIVE))
self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, self->dest_name, FALSE));
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_PROTO |
#if ENABLE_SSL
(((self->flags & AFSOCKET_STREAM) && !self->tls_context) ? LW_DETECT_EOF : 0) |
#else
((self->flags & AFSOCKET_STREAM) ? LW_DETECT_EOF : 0) |
#endif
(self->flags & AFSOCKET_SYSLOG_PROTOCOL ? LW_SYSLOG_PROTOCOL : 0));
log_writer_set_options((LogWriter *) self->writer, &self->super.super, &self->writer_options, 0, afsocket_dd_stats_source(self), self->super.id, afsocket_dd_stats_instance(self));
log_pipe_init(self->writer, NULL);
log_pipe_append(&self->super.super, self->writer);
}
afsocket_dd_reconnect(self);
return TRUE;
}
static void
testcase(gchar *msg, gchar *timezone, gchar *format, gchar *expected)
{
LogTemplate *templ;
LogMessage *logmsg;
LogParser *parser;
gboolean success;
GString *res = g_string_sized_new(128);
parser = date_parser_new (configuration);
if (format != NULL) date_parser_set_format(parser, format);
if (timezone != NULL) date_parser_set_timezone(parser, timezone);
log_pipe_init(&parser->super);
logmsg = log_msg_new_empty();
logmsg->timestamps[LM_TS_RECVD].tv_sec = 1451473200; /* Dec 30 2015 */
log_msg_set_value(logmsg, log_msg_get_value_handle("MESSAGE"), msg, -1);
success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
if (!success && expected)
{
fprintf(stderr, "unable to parse format=%s msg=%s\n", format, msg);
exit(1);
}
else if (success && !expected)
{
fprintf(stderr, "successfully parsed but expected failure, format=%s msg=%s\n", format, msg);
exit(1);
}
else if (expected)
{
/* Convert to ISODATE */
templ = compile_template("${ISODATE}", FALSE);
log_template_format(templ, logmsg, NULL, LTZ_LOCAL, -1, NULL, res);
assert_nstring(res->str, res->len, expected, strlen(expected),
"incorrect date parsed msg=%s format=%s",
msg, format);
log_template_unref(templ);
}
g_string_free(res, TRUE);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
return;
}
Test(logthrdestdrv, test_connect_failure_kicks_in_suspend_retry_logic_which_keeps_reconnecting_until_successful)
{
/* the dd created by setup() is not good for us */
_teardown_dd();
/* we are asserting on a debug message */
debug_flag = TRUE;
start_grabbing_messages();
dd = test_threaded_dd_new(main_loop_get_current_config(main_loop));
dd->super.worker.connect = _connect_failure;
dd->super.worker.insert = _insert_single_message_success;
dd->super.time_reopen = 0;
cr_assert(log_pipe_init(&dd->super.super.super.super));
_generate_message_and_wait_for_processing(dd, dd->super.written_messages);
cr_assert(dd->connect_counter == 11, "%d", dd->connect_counter);
assert_grabbed_log_contains("Error establishing connection to server");
}
static void
afprogram_dd_exit(pid_t pid, int status, gpointer s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
/* Note: self->pid being -1 means that deinit was called, thus we don't
* need to restart the command. self->pid might change due to EPIPE
* handling restarting the command before this handler is run. */
if (self->pid != -1 && self->pid == pid)
{
msg_verbose("Child program exited, restarting",
evt_tag_str("cmdline", self->cmdline->str),
evt_tag_int("status", status),
NULL);
self->pid = -1;
log_pipe_deinit(&self->super.super, NULL, NULL);
log_pipe_init(&self->super.super, NULL, NULL);
}
}
static gboolean
affile_sd_init(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
int fd, flags;
if (self->flags & AFFILE_PIPE)
flags = O_RDWR | O_NOCTTY | O_NONBLOCK | O_LARGEFILE;
else
flags = O_RDONLY | O_NOCTTY | O_NONBLOCK | O_LARGEFILE;
log_reader_options_init(&self->reader_options, cfg);
#if 0/*start dongshu*/
if (affile_open_file(self->filename->str, flags, -1, -1, -1, 0, 0, 0, 0, &fd))
#else
if (affile_open_file(self->filename->str, flags, -1, -1, -1, 0, 0, 0, 0, &fd,0))
#endif/*end*/
{
self->reader = log_reader_new(fd_read_new(fd, 0), LR_LOCAL | LR_NOMREAD, s, &self->reader_options);
log_pipe_append(self->reader, s);
/* call log_reader_init() */
if (!log_pipe_init(self->reader, NULL, 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
afinter_sd_init(LogPipe *s)
{
AFInterSourceDriver *self = (AFInterSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_src_driver_init_method(s))
return FALSE;
if (current_internal_source != NULL)
{
msg_error("Multiple internal() sources were detected, this is not possible", NULL);
return FALSE;
}
log_source_options_init(&self->source_options, cfg, self->super.group);
self->source = afinter_source_new(self, &self->source_options);
log_pipe_append(&self->source->super, s);
log_pipe_init(&self->source->super, cfg);
return TRUE;
}
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;
}
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 gboolean
trigger_sd_init (LogPipe *s)
{
TriggerSourceDriver *self = (TriggerSourceDriver *)s;
GlobalConfig *cfg = log_pipe_get_config (s);
if (!log_src_driver_init_method (s))
return FALSE;
if (self->options.trigger_freq <= 0)
self->options.trigger_freq = 10;
if (!self->options.message)
self->options.message = g_strdup ("Trigger source is trigger happy.");
log_source_options_init (&self->source_options, cfg, self->super.super.group);
self->source = trigger_source_new (self, &self->source_options, cfg);
log_pipe_append (&self->source->super, s);
log_pipe_init (&self->source->super);
return TRUE;
}
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
__start_source(gpointer user_data)
{
TestSource *self = (TestSource *)user_data;
log_pipe_init(&self->super);
}
static gboolean
afprogram_dd_init(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
int msg_pipe[2];
if (cfg)
log_writer_options_init(&self->writer_options, cfg, 0, afprogram_dd_format_stats_name(self));
msg_verbose("Starting destination program",
evt_tag_str("cmdline", self->cmdline->str),
NULL);
if (pipe(msg_pipe) == -1)
{
msg_error("Error creating program pipe",
evt_tag_str("cmdline", self->cmdline->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return FALSE;
}
if ((self->pid = fork()) < 0)
{
msg_error("Error in fork()",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(msg_pipe[0]);
close(msg_pipe[1]);
return FALSE;
}
if (self->pid == 0)
{
/* child */
int devnull = open("/dev/null", O_WRONLY);
if (devnull == -1)
{
_exit(127);
}
dup2(msg_pipe[0], 0);
dup2(devnull, 1);
dup2(devnull, 2);
close(devnull);
close(msg_pipe[0]);
close(msg_pipe[1]);
execl("/bin/sh", "/bin/sh", "-c", self->cmdline->str, NULL);
_exit(127);
}
else
{
/* parent */
child_manager_register(self->pid, afprogram_dd_exit, log_pipe_ref(&self->super.super), (GDestroyNotify) log_pipe_unref);
close(msg_pipe[0]);
g_fd_set_nonblock(msg_pipe[1], TRUE);
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_FILE, s, &self->writer_options);
#if 0/*start dongshu*/
log_writer_reopen(self->writer, fd_write_new(msg_pipe[1]));
#else
log_writer_reopen(self->writer, fd_write_new(msg_pipe[1],NULL));
#endif/*end*/
log_pipe_init(self->writer, NULL, NULL);
log_pipe_append(&self->super.super, self->writer);
}
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;
}
