static gboolean
afprogram_dd_deinit(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
if (self->pid != -1)
{
msg_verbose("Sending destination program a TERM signal",
evt_tag_str("cmdline", self->cmdline->str),
evt_tag_int("child_pid", self->pid),
NULL);
kill(-self->pid, SIGTERM);
self->pid = -1;
}
if (self->writer)
{
log_pipe_deinit(self->writer);
log_pipe_unref(self->writer);
self->writer = NULL;
}
if (!log_dest_driver_deinit_method(s))
return FALSE;
return TRUE;
}
static gboolean
__deinit(LogPipe *s)
{
TestSource *self = (TestSource *)s;
journal_reader_options_destroy(&self->options);
log_pipe_deinit((LogPipe *)self->reader);
log_pipe_unref((LogPipe *)self->reader);
return TRUE;
}
gboolean
afsocket_sd_deinit(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if ((self->flags & AFSOCKET_KEEP_ALIVE) == 0 || !cfg->persist)
{
afsocket_sd_kill_connection_list(self->connections);
}
else
{
GList *p;
/* for AFSOCKET_STREAM source drivers this is a list, for
* AFSOCKET_DGRAM this is a single connection */
for (p = self->connections; p; p = p->next)
{
log_pipe_deinit((LogPipe *) p->data);
}
cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, FALSE), self->connections, (GDestroyNotify) afsocket_sd_kill_connection_list, FALSE);
}
self->connections = NULL;
if (self->flags & AFSOCKET_STREAM)
{
afsocket_sd_stop_watches(self);
if ((self->flags & AFSOCKET_KEEP_ALIVE) == 0)
{
msg_verbose("Closing listener fd",
evt_tag_int("fd", self->fd),
NULL);
close(self->fd);
}
else
{
/* NOTE: the fd is incremented by one when added to persistent config
* as persist config cannot store NULL */
cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, TRUE), GUINT_TO_POINTER(self->fd + 1), afsocket_sd_close_fd, FALSE);
}
}
else if (self->flags & AFSOCKET_DGRAM)
{
/* we don't need to close the listening fd here as we have a
* single connection which will close it */
;
}
if (!log_src_driver_deinit_method(s))
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
afsocket_sc_deinit(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
log_pipe_unref(&self->owner->super.super.super);
self->owner = NULL;
log_pipe_deinit((LogPipe *) self->reader);
return TRUE;
}
static gboolean
afprogram_dd_deinit(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
if (self->writer)
log_pipe_deinit(self->writer);
if (!log_dest_driver_deinit_method(s))
return FALSE;
return TRUE;
}
static gboolean
affile_sd_deinit(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
if (self->reader)
{
log_pipe_deinit(self->reader, NULL, NULL);
log_pipe_unref(self->reader);
self->reader = NULL;
}
return TRUE;
}
void
test_source_run_tests(TestSource *self)
{
self->current_test = self->tests;
while (self->current_test)
{
self->current_test_case = self->current_test->data;
iv_task_register(&self->start);
iv_main();
log_pipe_deinit(&self->super);
self->current_test = self->current_test->next;
}
}
static void
afsocket_sd_kill_connection(AFSocketSourceConnection *connection)
{
log_pipe_deinit(&connection->super);
/* Remove the circular reference between the connection and its
* reader (through the connection->reader and reader->control
* pointers these have a circular references).
*/
log_pipe_unref((LogPipe *) connection->reader);
connection->reader = NULL;
log_pipe_unref(&connection->super);
}
static gboolean
afsocket_sc_deinit(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
self->owner->connections = g_list_remove(self->owner->connections, self);
log_pipe_unref(&self->owner->super.super);
self->owner = NULL;
log_pipe_deinit(self->reader);
log_pipe_unref(self->reader);
self->reader = NULL;
return TRUE;
}
static gboolean
__deinit(LogPipe *s)
{
SystemdJournalSourceDriver *self = (SystemdJournalSourceDriver *)s;
if (self->reader)
{
log_pipe_deinit((LogPipe *)self->reader);
log_pipe_unref((LogPipe *)self->reader);
self->reader = NULL;
}
log_src_driver_deinit_method(s);
return TRUE;
}
static gboolean
affile_sd_deinit(LogPipe *s)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (self->reader)
{
affile_sd_save_pos(s, cfg);
log_pipe_deinit(self->reader);
log_pipe_unref(self->reader);
self->reader = NULL;
}
return TRUE;
}
static gboolean
trigger_sd_deinit (LogPipe *s)
{
TriggerSourceDriver *self = (TriggerSourceDriver *)s;
if (self->source)
{
log_pipe_deinit (&self->source->super);
log_pipe_unref (&self->source->super);
self->source = NULL;
}
g_free (self->options.message);
return log_src_driver_deinit_method (s);
}
static gboolean
affile_sd_deinit(LogPipe *s)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
if (self->reader)
{
log_pipe_deinit((LogPipe *) self->reader);
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
}
if (!log_src_driver_deinit_method(s))
return FALSE;
return TRUE;
}
static gboolean
afprogram_dd_deinit(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
afprogram_dd_kill_child(self);
if (self->writer)
{
log_pipe_deinit(self->writer);
log_pipe_unref(self->writer);
self->writer = NULL;
}
if (!log_dest_driver_deinit_method(s))
return FALSE;
return TRUE;
}
static gboolean
afprogram_dd_deinit(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
if (self->pid != -1)
{
msg_verbose("Sending child a TERM signal",
evt_tag_int("child_pid", self->pid),
NULL);
kill(self->pid, SIGTERM);
self->pid = -1;
}
if (self->writer)
log_pipe_deinit(self->writer, NULL, NULL);
return TRUE;
}
static gboolean
afprogram_sd_deinit(LogPipe *s)
{
AFProgramSourceDriver *self = (AFProgramSourceDriver *) s;
afprogram_sd_kill_child(self);
if (self->reader)
{
log_pipe_deinit(self->reader);
log_pipe_unref(self->reader);
self->reader = NULL;
}
if (!log_src_driver_deinit_method(s))
return FALSE;
return TRUE;
}
static gboolean
afinter_sd_deinit(LogPipe *s)
{
AFInterSourceDriver *self = (AFInterSourceDriver *) s;
if (self->source)
{
log_pipe_deinit(&self->source->super);
/* break circular reference created during _init */
log_pipe_unref(&self->source->super);
self->source = NULL;
}
if (!log_src_driver_deinit_method(s))
return FALSE;
return TRUE;
}
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 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--;
}
static gboolean
log_source_group_deinit(LogPipe *s)
{
LogSourceGroup *self = (LogSourceGroup *) s;
LogDriver *p;
gboolean success = TRUE;
stats_unregister_counter(SCS_SOURCE | SCS_GROUP, self->name, NULL, SC_TYPE_PROCESSED, &self->processed_messages);
for (p = self->drivers; p; p = p->drv_next)
{
if (!log_pipe_deinit(&p->super))
{
msg_error("Error deinitializing source driver",
evt_tag_str("source", self->name),
evt_tag_str("id", p->id),
NULL);
success = FALSE;
}
}
return success;
}
gboolean
afsocket_dd_deinit(LogPipe *s)
{
AFSocketDestDriver *self = (AFSocketDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
afsocket_dd_stop_watches(self);
if (self->writer)
log_pipe_deinit(self->writer);
if (self->flags & AFSOCKET_KEEP_ALIVE)
{
cfg_persist_config_add(cfg, afsocket_dd_format_persist_name(self, FALSE), self->writer, (GDestroyNotify) log_pipe_unref, FALSE);
self->writer = NULL;
}
if (!log_dest_driver_deinit_method(s))
return FALSE;
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
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;
}
static void
afsocket_sd_save_connections(AFSocketSourceDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
if (!self->connections_kept_alive_accross_reloads || !cfg->persist)
{
afsocket_sd_kill_connection_list(self->connections);
}
else
{
GList *p;
/* for SOCK_STREAM source drivers this is a list, for
* SOCK_DGRAM this is a single connection */
for (p = self->connections; p; p = p->next)
{
log_pipe_deinit((LogPipe *) p->data);
}
cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, FALSE), self->connections, (GDestroyNotify) afsocket_sd_kill_connection_list, FALSE);
}
self->connections = NULL;
}
static void
_deleted_cb(FileReader *self, gpointer user_data)
{
log_pipe_deinit(&self->super);
file_reader_remove_persist_state(self);
}
static void
destroy_parser(LogParser *snmptrapd_parser)
{
log_pipe_deinit((LogPipe *)snmptrapd_parser);
log_pipe_unref((LogPipe *)snmptrapd_parser);
}
static void
afsocket_dd_stop_writer(AFSocketDestDriver *self)
{
if (self->writer)
log_pipe_deinit((LogPipe *) self->writer);
}
static void
afsocket_sd_kill_connection(AFSocketSourceConnection *sc)
{
log_pipe_deinit(&sc->super);
log_pipe_unref(&sc->super);
}
