static gboolean
afsocket_dd_connected(AFSocketDestDriver *self)
{
gchar buf1[256], buf2[256];
int error = 0;
socklen_t errorlen = sizeof(error);
LogTransport *transport;
LogProtoClient *proto;
main_loop_assert_main_thread();
if (iv_fd_registered(&self->connect_fd))
iv_fd_unregister(&self->connect_fd);
if (self->transport_mapper->sock_type == SOCK_STREAM)
{
if (getsockopt(self->fd, SOL_SOCKET, SO_ERROR, &error, &errorlen) == -1)
{
msg_error("getsockopt(SOL_SOCKET, SO_ERROR) failed for connecting socket",
evt_tag_int("fd", self->fd),
evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
evt_tag_int("time_reopen", self->time_reopen),
NULL);
goto error_reconnect;
}
if (error)
{
msg_error("Syslog connection failed",
evt_tag_int("fd", self->fd),
evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, error),
evt_tag_int("time_reopen", self->time_reopen),
NULL);
goto error_reconnect;
}
}
msg_notice("Syslog connection established",
evt_tag_int("fd", self->fd),
evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf1, sizeof(buf1), GSA_FULL)),
NULL);
transport = afsocket_dd_construct_transport(self, self->fd);
if (!transport)
goto error_reconnect;
proto = log_proto_client_factory_construct(self->proto_factory, transport, &self->writer_options.proto_options.super);
log_writer_reopen(self->writer, proto);
return TRUE;
error_reconnect:
close(self->fd);
self->fd = -1;
afsocket_dd_start_reconnect_timer(self);
return FALSE;
}
void
control_server_start(ControlServer *s)
{
ControlServerUnix *self = (ControlServerUnix *)s;
GSockAddr *saddr;
saddr = g_sockaddr_unix_new(self->super.control_socket_name);
self->control_socket = socket(PF_UNIX, SOCK_STREAM, 0);
if (self->control_socket == -1)
{
msg_error("Error opening control socket, external controls will not be available",
evt_tag_str("socket", self->super.control_socket_name),
NULL);
return;
}
if (g_bind(self->control_socket, saddr) != G_IO_STATUS_NORMAL)
{
msg_error("Error opening control socket, bind() failed",
evt_tag_str("socket", self->super.control_socket_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
if (listen(self->control_socket, 255) < 0)
{
msg_error("Error opening control socket, listen() failed",
evt_tag_str("socket", self->super.control_socket_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
self->control_listen.fd = self->control_socket;
self->control_listen.cookie = self;
iv_fd_register(&self->control_listen);
iv_fd_set_handler_in(&self->control_listen, control_socket_accept);
g_sockaddr_unref(saddr);
return;
error:
if (self->control_socket != -1)
{
close(self->control_socket);
self->control_socket = -1;
}
g_sockaddr_unref(saddr);
return;
}
static void
control_connection_io_output(gpointer s)
{
ControlConnection *self = (ControlConnection *) s;
gint rc;
rc = write(self->control_io.fd, self->output_buffer->str + self->pos, self->output_buffer->len - self->pos);
if (rc < 0)
{
if (errno != EAGAIN)
{
msg_error("Error writing control channel",
evt_tag_errno("error", errno),
NULL);
control_connection_stop_watches(self);
control_connection_free(self);
return;
}
}
else
{
self->pos += rc;
}
control_connection_update_watches(self);
}
gboolean
cfg_read_config(GlobalConfig *self, gchar *fname, gboolean syntax_only, gchar *preprocess_into)
{
FILE *cfg_file;
gint res;
self->filename = fname;
if ((cfg_file = fopen(fname, "r")) != NULL)
{
CfgLexer *lexer;
lexer = cfg_lexer_new(cfg_file, fname, preprocess_into);
res = cfg_run_parser(self, lexer, &main_parser, (gpointer *) &self, NULL);
fclose(cfg_file);
if (res)
{
/* successfully parsed */
return TRUE;
}
}
else
{
msg_error("Error opening configuration file",
evt_tag_str(EVT_TAG_FILENAME, fname),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
}
return FALSE;
}
static void
system_sysblock_add_linux_kmsg(GString *sysblock)
{
gchar *kmsg = "/proc/kmsg";
int fd;
gchar *format = NULL;
if ((fd = open("/dev/kmsg", O_RDONLY)) != -1)
{
if ((lseek (fd, 0, SEEK_END) != -1) && _is_fd_pollable(fd))
{
kmsg = "/dev/kmsg";
format = "linux-kmsg";
}
close (fd);
}
if (access(kmsg, R_OK) == -1)
{
msg_warning("system(): The kernel message buffer is not readable, "
"please check permissions if this is unintentional.",
evt_tag_str("device", kmsg),
evt_tag_errno("error", errno),
NULL);
}
else
system_sysblock_add_file(sysblock, kmsg, -1,
"kernel", "kernel", format);
}
FilterExprNode *
filter_in_list_new(const gchar *list_file, const gchar *property)
{
FilterInList *self;
FILE *stream;
gchar line[16384];
stream = fopen(list_file, "r");
if (!stream)
{
msg_error("Error opening in-list filter list file",
evt_tag_str("file", list_file),
evt_tag_errno("errno", errno),
NULL);
return NULL;
}
self = g_new0(FilterInList, 1);
filter_expr_node_init_instance(&self->super);
self->value_handle = log_msg_get_value_handle(property);
self->tree = g_tree_new_full((GCompareDataFunc)strcmp, NULL, g_free, NULL);
while (fgets(line, sizeof(line), stream) != NULL)
{
line[strlen(line) - 1] = '\0';
if (line[0])
g_tree_insert(self->tree, g_strdup(line), GINT_TO_POINTER(1));
}
fclose(stream);
self->super.eval = filter_in_list_eval;
self->super.free_fn = filter_in_list_free;
return &self->super;
}
/**
* cap_restore:
* @r: capability set saved by cap_save()
*
* Restore the set of current capabilities specified by @r.
*
* Returns: whether the operation was successful.
**/
void
g_process_cap_restore(cap_t r)
{
gboolean rc;
if (!process_opts.caps)
return;
rc = cap_set_proc(r) != -1;
cap_free(r);
if (!rc)
{
gchar *cap_text;
cap_text = cap_to_text(r, NULL);
msg_error("Error managing capability set, cap_set_proc returned an error",
evt_tag_str("caps", cap_text),
evt_tag_errno("error", errno),
NULL);
cap_free(cap_text);
return;
}
return;
}
static gboolean
control_socket_accept(gpointer user_data)
{
gint conn_socket;
GSockAddr *peer_addr;
GIOStatus status;
GIOChannel *channel;
if (control_socket == -1)
return FALSE;
status = g_accept(control_socket, &conn_socket, &peer_addr);
if (status != G_IO_STATUS_NORMAL)
{
msg_error("Error accepting control socket connection",
evt_tag_errno("error", errno),
NULL);
goto error;
}
g_sockaddr_unref(peer_addr);
channel = g_io_channel_unix_new(conn_socket);
g_io_channel_set_encoding(channel, NULL, NULL);
g_io_channel_set_close_on_unref(channel, TRUE);
g_io_add_watch(channel, G_IO_IN, control_channel_input, NULL);
g_io_channel_unref(channel);
error:
return TRUE;
}
static gint
_fetch_log(JournalReader *self)
{
gint msg_count = 0;
gint result = 0;
self->immediate_check = TRUE;
while (msg_count < self->options->fetch_limit && !main_loop_worker_job_quit())
{
gint rc = journald_next(self->journal);
if (rc > 0)
{
Bookmark *bookmark = ack_tracker_request_bookmark(self->super.ack_tracker);
_fill_bookmark(self, bookmark);
msg_count++;
if (!_handle_message(self))
{
break;
}
}
else
{
self->immediate_check = FALSE;
/* rc == 0 means EOF */
if (rc < 0)
{
msg_error("Error occurred while getting next message from journal",
evt_tag_errno("error", errno));
result = NC_READ_ERROR;
}
break;
}
}
return result;
}
void
control_init(const gchar *control_name)
{
GSockAddr *saddr;
saddr = g_sockaddr_unix_new(control_name);
control_socket = socket(PF_UNIX, SOCK_STREAM, 0);
if (control_socket == -1)
{
msg_error("Error opening control socket, external controls will not be available",
evt_tag_str("socket", control_name),
NULL);
return;
}
if (g_bind(control_socket, saddr) != G_IO_STATUS_NORMAL)
{
msg_error("Error opening control socket, bind() failed",
evt_tag_str("socket", control_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
if (listen(control_socket, 255) < 0)
{
msg_error("Error opening control socket, listen() failed",
evt_tag_str("socket", control_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
IV_FD_INIT(&control_listen);
control_listen.fd = control_socket;
control_listen.handler_in = control_socket_accept;
iv_fd_register(&control_listen);
g_sockaddr_unref(saddr);
return;
error:
if (control_socket != -1)
{
close(control_socket);
control_socket = -1;
}
g_sockaddr_unref(saddr);
}
void
control_init(const gchar *control_name, GMainContext *main_context)
{
GSockAddr *saddr;
GSource *source;
saddr = g_sockaddr_unix_new(control_name);
control_socket = socket(PF_UNIX, SOCK_STREAM, 0);
if (control_socket == -1)
{
msg_error("Error opening control socket, external controls will not be available",
evt_tag_str("socket", control_name),
NULL);
return;
}
if (g_bind(control_socket, saddr) != G_IO_STATUS_NORMAL)
{
msg_error("Error opening control socket, bind() failed",
evt_tag_str("socket", control_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
if (listen(control_socket, 255) < 0)
{
msg_error("Error opening control socket, listen() failed",
evt_tag_str("socket", control_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
source = g_listen_source_new(control_socket);
g_source_set_callback(source, control_socket_accept, NULL, NULL);
g_source_attach(source, main_context);
g_source_unref(source);
g_sockaddr_unref(saddr);
return;
error:
if (control_socket != -1)
{
close(control_socket);
control_socket = -1;
}
g_sockaddr_unref(saddr);
}
static void
afsocket_sd_accept(gpointer s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
GSockAddr *peer_addr;
gchar buf1[256], buf2[256];
gint new_fd;
gboolean res;
int accepts = 0;
while (accepts < MAX_ACCEPTS_AT_A_TIME)
{
GIOStatus status;
status = g_accept(self->fd, &new_fd, &peer_addr);
if (status == G_IO_STATUS_AGAIN)
{
/* no more connections to accept */
break;
}
else if (status != G_IO_STATUS_NORMAL)
{
msg_error("Error accepting new connection",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return;
}
g_fd_set_nonblock(new_fd, TRUE);
g_fd_set_cloexec(new_fd, TRUE);
res = afsocket_sd_process_connection(self, peer_addr, self->bind_addr, new_fd);
if (res)
{
if (peer_addr->sa.sa_family != AF_UNIX)
msg_notice("Syslog connection accepted",
evt_tag_int("fd", new_fd),
evt_tag_str("client", g_sockaddr_format(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 accepted",
evt_tag_int("fd", new_fd),
evt_tag_str("client", g_sockaddr_format(peer_addr, buf1, sizeof(buf1), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
NULL);
}
else
{
close(new_fd);
}
g_sockaddr_unref(peer_addr);
accepts++;
}
return;
}
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;
}
/**
* g_process_cap_modify:
* @capability: capability to turn off or on
* @onoff: specifies whether the capability should be enabled or disabled
*
* This function modifies the current permitted set of capabilities by
* enabling or disabling the capability specified in @capability.
*
* Returns: whether the operation was successful.
**/
gboolean
g_process_cap_modify(int capability, int onoff)
{
cap_t caps;
if (!process_opts.caps)
return TRUE;
/*
* if libcap or kernel doesn't support cap_syslog, then resort to
* cap_sys_admin
*/
if (capability == CAP_SYSLOG && (!have_capsyslog || CAP_SYSLOG == -1))
capability = CAP_SYS_ADMIN;
caps = cap_get_proc();
if (!caps)
return FALSE;
if (cap_set_flag(caps, CAP_EFFECTIVE, 1, &capability, onoff) == -1)
{
msg_error("Error managing capability set, cap_set_flag returned an error",
evt_tag_errno("error", errno),
NULL);
cap_free(caps);
return FALSE;
}
if (cap_set_proc(caps) == -1)
{
gchar *cap_text;
cap_text = cap_to_text(caps, NULL);
msg_error("Error managing capability set, cap_set_proc returned an error",
evt_tag_str("caps", cap_text),
evt_tag_errno("error", errno),
NULL);
cap_free(cap_text);
cap_free(caps);
return FALSE;
}
cap_free(caps);
return TRUE;
}
gboolean
transport_mapper_open_socket(TransportMapper *self,
SocketOptions *socket_options,
GSockAddr *bind_addr,
AFSocketDirection dir,
int *fd)
{
gint sock;
sock = socket(self->address_family, self->sock_type, self->sock_proto);
if (sock < 0)
{
msg_error("Error creating socket",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
goto error;
}
g_fd_set_nonblock(sock, TRUE);
g_fd_set_cloexec(sock, TRUE);
if (!transport_mapper_privileged_bind(sock, bind_addr))
{
gchar buf[256];
msg_error("Error binding socket",
evt_tag_str("addr", g_sockaddr_format(bind_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
goto error_close;
}
if (!socket_options_setup_socket(socket_options, sock, bind_addr, dir))
goto error_close;
*fd = sock;
return TRUE;
error_close:
close(sock);
error:
*fd = -1;
return FALSE;
}
static gboolean
afsocket_open_socket(GSockAddr *bind_addr, int stream_or_dgram, int *fd)
{
gint sock;
if (stream_or_dgram)
sock = socket(bind_addr->sa.sa_family, SOCK_STREAM, 0);
else
sock = socket(bind_addr->sa.sa_family, SOCK_DGRAM, 0);
if (sock != -1)
{
cap_t saved_caps;
g_fd_set_nonblock(sock, TRUE);
g_fd_set_cloexec(sock, TRUE);
saved_caps = g_process_cap_save();
g_process_cap_modify(CAP_NET_BIND_SERVICE, TRUE);
g_process_cap_modify(CAP_DAC_OVERRIDE, TRUE);
if (g_bind(sock, bind_addr) != G_IO_STATUS_NORMAL)
{
gchar buf[256];
g_process_cap_restore(saved_caps);
msg_error("Error binding socket",
evt_tag_str("addr", g_sockaddr_format(bind_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(sock);
return FALSE;
}
g_process_cap_restore(saved_caps);
*fd = sock;
return TRUE;
}
else
{
msg_error("Error creating socket",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return FALSE;
}
}
static void
afstreams_init_door(int hook_type G_GNUC_UNUSED, gpointer user_data)
{
AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) user_data;
struct stat st;
gint fd;
if (stat(self->door_filename->str, &st) == -1)
{
/* file does not exist, create it */
fd = creat(self->door_filename->str, 0666);
if (fd == -1)
{
msg_error("Error creating syslog door file",
evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(fd);
return;
}
}
fdetach(self->door_filename->str);
self->door_fd = door_create(afstreams_sd_door_server_proc, NULL, 0);
if (self->door_fd == -1)
{
msg_error("Error creating syslog door",
evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return;
}
g_fd_set_cloexec(self->door_fd, TRUE);
if (fattach(self->door_fd, self->door_filename->str) == -1)
{
msg_error("Error attaching syslog door",
evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(self->door_fd);
self->door_fd = -1;
return;
}
}
gboolean
confgen_generate(CfgLexer *lexer, gint type, const gchar *name, CfgArgs *args, gpointer user_data)
{
gchar *value;
gsize value_len = 0;
FILE *out;
gchar *exec = (gchar *) user_data;
gsize res;
gchar buf[256];
g_snprintf(buf, sizeof(buf), "%s confgen %s", cfg_lexer_lookup_context_name_by_type(type), name);
if (!cfg_args_validate(args, NULL, buf))
{
msg_error("confgen: confgen invocations do not process arguments, but your argument list is not empty",
evt_tag_str("context", cfg_lexer_lookup_context_name_by_type(type)),
evt_tag_str("block", name),
NULL);
return FALSE;
}
out = popen((gchar *) user_data, "r");
if (!out)
{
msg_error("confgen: Error executing generator program",
evt_tag_str("context", cfg_lexer_lookup_context_name_by_type(type)),
evt_tag_str("block", name),
evt_tag_str("exec", exec),
evt_tag_errno("error", errno),
NULL);
return FALSE;
}
value = g_malloc(1024);
while ((res = fread(value + value_len, 1, 1024, out)) > 0)
{
value_len += res;
value = g_realloc(value, value_len + 1024);
}
res = pclose(out);
if (res != 0)
{
msg_error("confgen: Generator program returned with non-zero exit code",
evt_tag_str("block", name),
evt_tag_str("exec", exec),
evt_tag_int("rc", res),
NULL);
g_free(value);
return FALSE;
}
if (!cfg_lexer_include_buffer(lexer, buf, value, value_len))
{
g_free(value);
return FALSE;
}
return TRUE;
}
gboolean
afsocket_dd_start_connect(AFSocketDestDriver *self)
{
int sock, rc;
gchar buf1[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
{
return FALSE;
}
if (self->setup_socket && !self->setup_socket(self, sock))
{
close(sock);
return FALSE;
}
rc = g_connect(sock, self->dest_addr);
if (rc == G_IO_STATUS_NORMAL)
{
self->fd = sock;
afsocket_dd_connected(self);
}
else if (rc == G_IO_STATUS_ERROR && errno == EINPROGRESS)
{
GSource *source;
/* we must wait until connect succeeds */
self->fd = sock;
source = g_connect_source_new(sock);
/* a reference is added on behalf of the source, it will be unrefed when
* the source is destroyed */
log_pipe_ref(&self->super.super);
g_source_set_callback(source, (GSourceFunc) afsocket_dd_connected, self, (GDestroyNotify) log_pipe_unref);
self->source_id = g_source_attach(source, NULL);
g_source_unref(source);
}
else
{
/* error establishing connection */
msg_error("Connection failed",
evt_tag_int("fd", sock),
evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf1, sizeof(buf1), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(sock);
return FALSE;
}
return TRUE;
}
static LogProtoStatus
log_proto_framed_server_fetch_data(LogProtoFramedServer *self, gboolean *may_read)
{
gint rc;
if (self->buffer_pos == self->buffer_end)
self->buffer_pos = self->buffer_end = 0;
if (self->buffer_size == self->buffer_end)
{
/* no more space in the buffer, we can't fetch further data. Move the
* things we already have to the beginning of the buffer to make
* space. */
memmove(self->buffer, &self->buffer[self->buffer_pos], self->buffer_end - self->buffer_pos);
self->buffer_end = self->buffer_end - self->buffer_pos;
self->buffer_pos = 0;
}
if (!(*may_read))
return LPS_SUCCESS;
rc = log_transport_read(self->super.transport, &self->buffer[self->buffer_end], self->buffer_size - self->buffer_end, NULL);
if (rc < 0)
{
if (errno != EAGAIN)
{
msg_error("Error reading RFC5428 style framed data",
evt_tag_int("fd", self->super.transport->fd),
evt_tag_errno("error", errno),
NULL);
return LPS_ERROR;
}
else
{
/* we need more data to parse this message but the data is not available yet */
self->half_message_in_buffer = TRUE;
}
}
else if (rc == 0)
{
msg_verbose("EOF occurred while reading",
evt_tag_int(EVT_TAG_FD, self->super.transport->fd),
NULL);
return LPS_EOF;
}
else
{
self->buffer_end += rc;
}
return LPS_SUCCESS;
}
static int
_cfg_lexer_glob_err (const char *p, gint e)
{
if (e != ENOENT)
{
msg_debug ("Error processing path for inclusion",
evt_tag_str("path", p),
evt_tag_errno("errno", e));
return -1;
}
return 0;
}
static gboolean
file_exists(const gchar *fname)
{
if (!fname)
return FALSE;
if (access(fname, R_OK) < 0)
{
msg_error("Error opening TLS file",
evt_tag_str("filename", fname),
evt_tag_errno("error", errno),
NULL);
return FALSE;
}
return TRUE;
}
static gboolean
afsocket_dd_start_connect(AFSocketDestDriver *self)
{
int sock, rc;
gchar buf1[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
main_loop_assert_main_thread();
if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
{
return FALSE;
}
if (self->setup_socket && !self->setup_socket(self, sock))
{
close(sock);
return FALSE;
}
g_assert(self->dest_addr);
rc = g_connect(sock, self->dest_addr);
if (rc == G_IO_STATUS_NORMAL)
{
self->fd = sock;
afsocket_dd_connected(self);
}
else if (rc == G_IO_STATUS_ERROR && errno == EINPROGRESS)
{
/* we must wait until connect succeeds */
self->fd = sock;
afsocket_dd_start_watches(self);
}
else
{
/* error establishing connection */
msg_error("Connection failed",
evt_tag_int("fd", sock),
evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf1, sizeof(buf1), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(sock);
return FALSE;
}
return TRUE;
}
static gboolean
_load_queue(QDisk *self, GQueue *q, gint64 q_ofs, gint32 q_len, gint32 q_count)
{
GString *serialized;
SerializeArchive *sa;
gint i;
if (q_ofs)
{
gssize read_len;
serialized = g_string_sized_new(q_len);
g_string_set_size(serialized, q_len);
read_len = pread(self->fd, serialized->str, q_len, q_ofs);
if (read_len < 0 || read_len != q_len)
{
msg_error("Error reading in-memory buffer from disk-queue file",
evt_tag_str("filename", self->filename),
read_len < 0 ? evt_tag_errno("error", errno) : evt_tag_str("error", "short read"));
g_string_free(serialized, TRUE);
return FALSE;
}
sa = serialize_string_archive_new(serialized);
for (i = 0; i < q_count; i++)
{
LogMessage *msg;
msg = log_msg_new_empty();
if (log_msg_deserialize(msg, sa))
{
g_queue_push_tail(q, msg);
/* we restore the queue without ACKs */
g_queue_push_tail(q, GINT_TO_POINTER(0x80000000));
}
else
{
msg_error("Error reading message from disk-queue file (maybe currupted file) some messages will be lost",
evt_tag_str("filename", self->filename),
evt_tag_int("lost messages", q_count - i));
log_msg_unref(msg);
break;
}
}
g_string_free(serialized, TRUE);
serialize_archive_free(sa);
}
return TRUE;
}
static inline gboolean
_seek_to_head(JournalReader *self)
{
gint rc = journald_seek_head(self->journal);
if (rc != 0)
{
msg_error("Failed to seek to the start position of the journal",
evt_tag_errno("error", errno));
return FALSE;
}
else
{
msg_debug("Seeking the journal to the start position");
}
return TRUE;
}
static gboolean
_add_poll_events(JournalReader *self)
{
gint fd = journald_get_fd(self->journal);
if (fd < 0)
{
msg_error("Error setting up journal polling, journald_get_fd() returned failure",
evt_tag_errno("error", errno));
journald_close(self->journal);
return FALSE;
}
self->poll_events = poll_fd_events_new(fd);
poll_events_set_callback(self->poll_events, _io_process_async_input, self);
return TRUE;
}
static gboolean
riemann_dd_connect(RiemannDestDriver *self, gboolean reconnect)
{
if (reconnect && self->client)
return TRUE;
self->client = riemann_client_create(self->type, self->server, self->port);
if (!self->client)
{
msg_error("Error connecting to Riemann",
evt_tag_errno("errno", errno),
NULL);
return FALSE;
}
return TRUE;
}
static gboolean
_truncate_file(QDisk *self, gint64 new_size)
{
gboolean success = TRUE;
if (ftruncate(self->fd, (glong)new_size) < 0)
{
success = FALSE;
msg_error("Error truncating disk-queue file",
evt_tag_errno("error", errno),
evt_tag_str("filename", self->filename),
evt_tag_int("newsize",self->hdr->write_head),
evt_tag_int("fd",self->fd));
}
return success;
}
static LogProtoStatus
log_proto_text_client_flush(LogProtoClient *s)
{
LogProtoTextClient *self = (LogProtoTextClient *) s;
gint rc;
/* attempt to flush previously buffered data */
if (self->partial)
{
gint len = self->partial_len - self->partial_pos;
rc = log_transport_write(self->super.transport, &self->partial[self->partial_pos], len);
if (rc < 0)
{
if (errno != EAGAIN && errno != EINTR)
{
msg_error("I/O error occurred while writing",
evt_tag_int("fd", self->super.transport->fd),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return LPS_ERROR;
}
return LPS_SUCCESS;
}
else if (rc != len)
{
self->partial_pos += rc;
return LPS_SUCCESS;
}
else
{
if (self->partial_free)
self->partial_free(self->partial);
self->partial = NULL;
if (self->next_state >= 0)
{
self->state = self->next_state;
self->next_state = -1;
}
/* NOTE: we return here to give a chance to the framed protocol to send the frame header. */
return LPS_SUCCESS;
}
}
return LPS_SUCCESS;
}
static gboolean
_create_store(PersistState *self)
{
self->fd = open(self->temp_filename, O_RDWR | O_CREAT | O_TRUNC, 0600);
if (self->fd < 0)
{
msg_error("Error creating persistent state file",
evt_tag_str("filename", self->temp_filename),
evt_tag_errno("error", errno),
NULL);
return FALSE;
}
g_fd_set_cloexec(self->fd, TRUE);
self->current_key_block = offsetof(PersistFileHeader, initial_key_store);
self->current_key_ofs = 0;
self->current_key_size = sizeof((((PersistFileHeader *) NULL))->initial_key_store);
return _grow_store(self, PERSIST_FILE_INITIAL_SIZE);
}
