gboolean
afsocket_sd_init_method(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
return log_src_driver_init_method(s) &&
afsocket_sd_setup_transport(self) &&
afsocket_sd_setup_addresses(self) &&
afsocket_sd_restore_kept_alive_connections(self) &&
afsocket_sd_open_listener(self);
}
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;
}
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 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 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;
}
gboolean
afsocket_sd_init(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
gint sock;
gboolean res = FALSE;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_src_driver_init_method(s))
return FALSE;
if (!afsocket_sd_apply_transport(self))
return FALSE;
g_assert(self->transport);
g_assert(self->bind_addr);
if ((self->flags & (AFSOCKET_STREAM + AFSOCKET_WNDSIZE_INITED)) == AFSOCKET_STREAM)
{
/* distribute the window evenly between each of our possible
* connections. This is quite pessimistic and can result in very low
* window sizes. Increase that but warn the user at the same time
*/
self->reader_options.super.init_window_size /= self->max_connections;
if (self->reader_options.super.init_window_size < 100)
{
msg_warning("WARNING: window sizing for tcp sources were changed in syslog-ng 3.3, the configuration value was divided by the value of max-connections(). The result was too small, clamping to 100 entries. Ensure you have a proper log_fifo_size setting to avoid message loss.",
evt_tag_int("orig_log_iw_size", self->reader_options.super.init_window_size),
evt_tag_int("new_log_iw_size", 100),
evt_tag_int("min_log_fifo_size", 100 * self->max_connections),
NULL);
self->reader_options.super.init_window_size = 100;
}
self->flags |= AFSOCKET_WNDSIZE_INITED;
}
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
/* fetch persistent connections first */
if ((self->flags & AFSOCKET_KEEP_ALIVE))
{
GList *p;
self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE));
for (p = self->connections; p; p = p->next)
{
afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self);
log_pipe_init((LogPipe *) p->data, NULL);
}
}
/* ok, we have connection list, check if we need to open a listener */
sock = -1;
if (self->flags & AFSOCKET_STREAM)
{
if (self->flags & AFSOCKET_KEEP_ALIVE)
{
/* NOTE: this assumes that fd 0 will never be used for listening fds,
* main.c opens fd 0 so this assumption can hold */
sock = GPOINTER_TO_UINT(cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, TRUE))) - 1;
}
if (sock == -1)
{
if (!afsocket_sd_acquire_socket(self, &sock))
return self->super.super.optional;
if (sock == -1 && !afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
return self->super.super.optional;
}
/* set up listening source */
if (listen(sock, self->listen_backlog) < 0)
{
msg_error("Error during listen()",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(sock);
return FALSE;
}
if (self->setup_socket && !self->setup_socket(self, sock))
{
close(sock);
return FALSE;
}
self->fd = sock;
afsocket_sd_start_watches(self);
res = TRUE;
}
else
{
if (!self->connections)
{
if (!afsocket_sd_acquire_socket(self, &sock))
return self->super.super.optional;
if (sock == -1 && !afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
return self->super.super.optional;
}
self->fd = -1;
if (!self->setup_socket(self, sock))
{
close(sock);
return FALSE;
}
/* we either have self->connections != NULL, or sock contains a new fd */
if (self->connections || afsocket_sd_process_connection(self, NULL, self->bind_addr, sock))
res = TRUE;
}
return res;
}
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);
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;
LogProto *proto;
transport = log_transport_plain_new(fd, 0);
transport->timeout = 10;
proto = affile_sd_construct_proto(self, transport);
/* FIXME: we shouldn't use reader_options to store log protocol parameters */
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);
/* 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(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;
}
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;
}
