static gboolean
_setup_auth_header(LogPipe *s)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
HttpAuthHeader *prev_auth_header = cfg_persist_config_fetch(cfg, _format_auth_header_name(s));
if (prev_auth_header)
{
http_auth_header_free(self->auth_header);
self->auth_header = prev_auth_header;
msg_debug("Auth header instance found in persist cfg",
log_pipe_location_tag(s));
return TRUE;
}
if (self->auth_header)
{
if (!http_auth_header_init(self->auth_header))
{
return FALSE;
}
_load_auth_header(s);
}
return TRUE;
}
static void
afsocket_dd_restore_connection(AFSocketDestDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, 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;
}
static gboolean
afsocket_sd_open_listener(AFSocketSourceDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
gint sock;
gboolean res = FALSE;
/* ok, we have connection list, check if we need to open a listener */
sock = -1;
if (self->transport_mapper->sock_type == SOCK_STREAM)
{
if (self->connections_kept_alive_accross_reloads)
{
/* 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 && !transport_mapper_open_socket(self->transport_mapper, self->socket_options, self->bind_addr, AFSOCKET_DIR_RECV, &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;
}
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 && !transport_mapper_open_socket(self->transport_mapper, self->socket_options, self->bind_addr, AFSOCKET_DIR_RECV, &sock))
return self->super.super.optional;
}
self->fd = -1;
/* 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;
}
gboolean
log_threaded_dest_driver_start(LogPipe *s)
{
LogThrDestDriver *self = (LogThrDestDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (cfg && self->time_reopen == -1)
self->time_reopen = cfg->time_reopen;
self->queue = log_dest_driver_acquire_queue(&self->super,
self->format.persist_name(self));
if (self->queue == NULL)
{
return FALSE;
}
if (self->retries.max <= 0)
{
msg_warning("Wrong value for retries(), setting to default",
evt_tag_int("value", self->retries.max),
evt_tag_int("default", MAX_RETRIES_OF_FAILED_INSERT_DEFAULT),
evt_tag_str("driver", self->super.super.id),
NULL);
self->retries.max = MAX_RETRIES_OF_FAILED_INSERT_DEFAULT;
}
stats_lock();
stats_register_counter(0, self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_register_counter(0, self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_register_counter(0, self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_PROCESSED, &self->processed_messages);
stats_unlock();
log_queue_set_counters(self->queue, self->stored_messages,
self->dropped_messages);
self->seq_num = GPOINTER_TO_INT(cfg_persist_config_fetch(cfg, log_threaded_dest_driver_format_seqnum_for_persist(self)));
if (!self->seq_num)
init_sequence_number(&self->seq_num);
log_threaded_dest_driver_start_thread(self);
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 void
afsocket_dd_restore_writer(AFSocketDestDriver *self)
{
GlobalConfig *cfg;
ReloadStoreItem *item;
g_assert(self->writer == NULL);
cfg = log_pipe_get_config(&self->super.super.super);
item = cfg_persist_config_fetch(cfg, afsocket_dd_format_connections_name(self));
if (item && !_is_protocol_type_changed_during_reload(self, item))
self->writer = _reload_store_item_release_writer(item);
_reload_store_item_free(item);
}
static gboolean
afprogram_dd_restore_reload_store_item(AFProgramDestDriver *self, GlobalConfig *cfg)
{
AFProgramReloadStoreItem *restored_info = (AFProgramReloadStoreItem *)cfg_persist_config_fetch(cfg, afprogram_dd_format_persist_name(self));
if (restored_info)
{
self->pid = restored_info->pid;
self->writer = restored_info->writer;
child_manager_register(self->pid, afprogram_dd_exit, log_pipe_ref(&self->super.super.super), (GDestroyNotify)log_pipe_unref);
g_free(restored_info);
}
return !!(self->writer);
}
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;
}
/* returns a reference */
static LogQueue *
log_dest_driver_acquire_queue_method(LogDestDriver *self, gchar *persist_name, gpointer user_data)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super);
LogQueue *queue = NULL;
g_assert(user_data == NULL);
if (persist_name)
queue = cfg_persist_config_fetch(cfg, persist_name);
if (!queue)
{
queue = log_queue_fifo_new(self->log_fifo_size < 0 ? cfg->log_fifo_size : self->log_fifo_size, persist_name);
log_queue_set_throttle(queue, self->throttle);
}
return queue;
}
static gboolean
log_db_parser_init(LogParser *s, GlobalConfig *cfg)
{
LogDBParser *self = (LogDBParser *) s;
if (self->initialized)
{
return TRUE;
}
self->initialized = TRUE;
self->db = cfg_persist_config_fetch(cfg, log_db_parser_format_persist_name(self));
if (self->db)
{
struct stat st;
if (stat(self->db_file, &st) < 0)
{
msg_error("Error stating pattern database file, no automatic reload will be performed",
evt_tag_str("error", g_strerror(errno)),
NULL);
}
else
{
self->db_file_inode = st.st_ino;
self->db_file_mtime = st.st_mtime;
}
}
else
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
}
if (self->db)
pattern_db_set_emit_func(self->db, log_db_parser_emit, self);
#if GLIB_MAJOR_VERSION > 2 && GLIB_MINOR_VERSION > 13
self->timer_tick_id = g_timeout_add_seconds(1, log_db_parser_timer_tick, self);
#else
self->timer_tick_id = g_timeout_add(1000, log_db_parser_timer_tick, self);
#endif
return self->db != NULL;
}
static gboolean
log_db_parser_init(LogPipe *s)
{
LogDBParser *self = (LogDBParser *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
self->db = cfg_persist_config_fetch(cfg, log_db_parser_format_persist_name(self));
if (self->db)
{
struct stat st;
if (stat(self->db_file, &st) < 0)
{
msg_error("Error stating pattern database file, no automatic reload will be performed",
evt_tag_str("error", g_strerror(errno)),
NULL);
}
else if (self->db_file_inode != st.st_ino || self->db_file_mtime != st.st_mtime)
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
self->db_file_inode = st.st_ino;
self->db_file_mtime = st.st_mtime;
}
}
else
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
}
if (self->db)
pattern_db_set_emit_func(self->db, log_db_parser_emit, self);
iv_validate_now();
IV_TIMER_INIT(&self->tick);
self->tick.cookie = self;
self->tick.handler = log_db_parser_timer_tick;
self->tick.expires = iv_now;
self->tick.expires.tv_sec++;
self->tick.expires.tv_nsec = 0;
iv_timer_register(&self->tick);
return self->db != NULL;
}
static void
affile_sd_load_pos(LogPipe *s, GlobalConfig *cfg)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
gchar *str;
off_t cur_pos;
gsize str_len;
gint version;
if ((self->flags & AFFILE_PIPE) || !cfg->persist)
return;
str = cfg_persist_config_fetch(cfg, affile_sd_format_persist_name(self), &str_len, &version);
if (!str)
return;
if (version == 2)
{
/* NOTE: legacy, should be removed once the release after 3.0 is published */
cur_pos = strtoll(str, NULL, 10);
log_reader_update_pos((LogReader *) self->reader, cur_pos);
g_free(str);
}
else if (version >= 3)
{
GString *g_str = g_string_new("");
SerializeArchive *archive;
g_str = g_string_assign_len(g_str, str, str_len);
archive = serialize_string_archive_new(g_str);
log_reader_restore_state((LogReader *) self->reader, archive);
serialize_archive_free(archive);
g_string_free(g_str, TRUE);
g_free(str);
}
}
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;
}
gboolean
afsocket_sd_init(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
gint sock;
gboolean res = FALSE;
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
if (!self->bind_addr)
{
msg_error("No bind address set;", NULL);
}
log_reader_options_init(&self->reader_options, cfg, self->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), NULL, NULL);
for (p = self->connections; p; p = p->next)
{
afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self);
}
}
/* ok, we have connection list, check if we need to open a listener */
sock = -1;
if (self->flags & AFSOCKET_STREAM)
{
GSource *source;
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), NULL, NULL)) - 1;
}
if (sock == -1)
{
if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
return self->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;
source = g_listen_source_new(self->fd);
/* the listen_source references us, which is freed when the source is deleted */
log_pipe_ref(s);
g_source_set_callback(source, afsocket_sd_accept, self, (GDestroyNotify) log_pipe_unref);
self->source_id = g_source_attach(source, NULL);
g_source_unref(source);
res = TRUE;
}
else
{
if (!self->connections)
{
if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
return self->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;
}
