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);
}
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
log_reader_set_peer_addr(LogReader *s, GSockAddr *peer_addr)
{
LogReader *self = (LogReader *) s;
g_sockaddr_unref(self->peer_addr);
self->peer_addr = g_sockaddr_ref(peer_addr);
}
static void
test_open_socket_fails_properly_on_bind_failure(void)
{
GSockAddr *addr = g_sockaddr_unix_new("/foo/bar/no/such/dir");
transport_mapper_set_address_family(transport_mapper, AF_UNIX);
assert_create_socket_fails_with_address(addr);
g_sockaddr_unref(addr);
}
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;
}
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));
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));
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));
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
afsocket_sc_free(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
g_assert(!self->reader);
g_sockaddr_unref(self->peer_addr);
log_pipe_free(s);
}
static gboolean
create_socket(gint *sock)
{
GSockAddr *addr = g_sockaddr_inet_new("127.0.0.1", 0);
gboolean success;
success = create_socket_with_address(addr, sock);
g_sockaddr_unref(addr);
return success;
}
static LogMessage *
kmsg_parse_message(const gchar *raw_message_str)
{
LogMessage *message;
GSockAddr *addr = g_sockaddr_inet_new("10.10.10.10", 1010);
message = log_msg_new(raw_message_str, strlen(raw_message_str), addr, &parse_options);
g_sockaddr_unref(addr);
return message;
}
void
afsocket_dd_free(LogPipe *s)
{
AFSocketDestDriver *self = (AFSocketDestDriver *) s;
log_writer_options_destroy(&self->writer_options);
g_sockaddr_unref(self->bind_addr);
g_sockaddr_unref(self->dest_addr);
log_pipe_unref(self->writer);
g_free(self->hostname);
g_free(self->dest_name);
g_free(self->transport);
#if ENABLE_SSL
if(self->tls_context)
{
tls_context_free(self->tls_context);
}
#endif
log_dest_driver_free(s);
}
void
afsocket_sd_free_method(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
log_reader_options_destroy(&self->reader_options);
transport_mapper_free(self->transport_mapper);
g_sockaddr_unref(self->bind_addr);
self->bind_addr = NULL;
log_src_driver_free(s);
}
static void
log_reader_free(LogPipe *s)
{
LogReader *self = (LogReader *) s;
/* when this function is called the source is already removed, because it
holds a reference to this reader */
log_pipe_unref(self->control);
g_sockaddr_unref(self->peer_addr);
g_free(self->follow_filename);
log_source_free(s);
}
static void
assert_sockaddr_to_hostname(GSockAddr *sa, const gchar *expected)
{
const gchar *result;
gsize result_len = 9999;
result = resolve_sockaddr_to_hostname(&result_len, sa, &host_resolve_options);
g_sockaddr_unref(sa);
assert_string(result, expected, "resolved name mismatch");
assert_gint(result_len, strlen(result), "returned length is not true");
}
static void
assert_hostname_to_sockaddr_fails(gint family, const gchar *hostname)
{
GSockAddr *sa = NULL;
gboolean result;
result = resolve_hostname_to_sockaddr(&sa, family, hostname);
g_sockaddr_unref(sa);
assert_null(sa, "returned sockaddr is non-NULL");
assert_false(result, "unexpected success returned");
}
void
afsocket_sd_free(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
log_reader_options_destroy(&self->reader_options);
g_sockaddr_unref(self->bind_addr);
self->bind_addr = NULL;
g_free(self->transport);
log_drv_free(s);
}
int
testcase_replace(const gchar *log, const gchar *re, gchar *replacement, const gchar *expected_result, const gint matcher_flags, LogMatcher *m)
{
LogMessage *msg;
LogTemplate *r;
gchar *result;
gssize length;
gchar buf[1024];
gssize msglen;
NVHandle nonasciiz = log_msg_get_value_handle("NON-ASCIIZ");
const gchar *value;
GSockAddr *sa;
sa = g_sockaddr_inet_new("10.10.10.10", 1010);
msg = log_msg_new(log, strlen(log), sa, &parse_options);
g_sockaddr_unref(sa);
/* NOTE: we test how our matchers cope with non-zero terminated values. We don't change message_len, only the value */
g_snprintf(buf, sizeof(buf), "%sAAAAAAAAAAAA", log_msg_get_value(msg, LM_V_MESSAGE, &msglen));
log_msg_set_value(msg, log_msg_get_value_handle("MESSAGE2"), buf, -1);
/* add a non-zero terminated indirect value which contains the whole message */
log_msg_set_value_indirect(msg, nonasciiz, log_msg_get_value_handle("MESSAGE2"), 0, 0, msglen);
log_matcher_set_flags(m, matcher_flags);
log_matcher_compile(m, re);
r = log_template_new(configuration, NULL);
log_template_compile(r, replacement, NULL);
NVTable *nv_table = nv_table_ref(msg->payload);
value = log_msg_get_value(msg, nonasciiz, &msglen);
result = log_matcher_replace(m, msg, nonasciiz, value, msglen, r, &length);
value = log_msg_get_value(msg, nonasciiz, &msglen);
nv_table_unref(nv_table);
if (strncmp(result ? result : value, expected_result, result ? length : msglen) != 0)
{
fprintf(stderr, "Testcase failure. pattern=%s, result=%.*s, expected=%s\n", re, (gint) length, result ? result : value, expected_result);
exit(1);
}
g_free(result);
log_template_unref(r);
log_matcher_unref(m);
log_msg_unref(msg);
return 0;
}
void
log_proto_buffered_server_free_method(LogProtoServer *s)
{
LogProtoBufferedServer *self = (LogProtoBufferedServer *) s;
g_sockaddr_unref(self->prev_saddr);
g_free(self->buffer);
if (self->state1)
{
g_free(self->state1);
}
log_proto_server_free_method(s);
}
static inline gint
log_proto_buffered_server_read_data(LogProtoBufferedServer *self, gpointer buffer, gsize count)
{
GSockAddr *sa = NULL;
gint rc;
rc = self->read_data(self, buffer, count, &sa);
if (sa)
{
/* new chunk of data, potentially new sockaddr, forget the previous value */
g_sockaddr_unref(self->prev_saddr);
self->prev_saddr = sa;
}
return rc;
}
static gboolean
afinet_dd_setup_addresses(AFSocketDestDriver *s)
{
AFInetDestDriver *self = (AFInetDestDriver *) s;
if (!afsocket_dd_setup_addresses_method(s))
return FALSE;
g_sockaddr_unref(self->super.bind_addr);
g_sockaddr_unref(self->super.dest_addr);
if (!resolve_hostname_to_sockaddr(&self->super.bind_addr, self->super.transport_mapper->address_family, self->bind_ip))
return FALSE;
if (self->bind_port)
g_sockaddr_set_port(self->super.bind_addr, afinet_lookup_service(self->super.transport_mapper, self->bind_port));
if (!resolve_hostname_to_sockaddr(&self->super.dest_addr, self->super.transport_mapper->address_family, self->hostname))
return FALSE;
if (!self->dest_port)
{
const gchar *port_change_warning = transport_mapper_inet_get_port_change_warning(self->super.transport_mapper);
if (port_change_warning)
{
msg_warning(port_change_warning,
evt_tag_str("id", self->super.super.super.id),
NULL);
}
}
g_sockaddr_set_port(self->super.dest_addr, _determine_port(self));
return TRUE;
}
static void
log_reader_free(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (self->proto)
{
log_proto_free(self->proto);
self->proto = NULL;
}
log_pipe_unref(self->control);
g_sockaddr_unref(self->peer_addr);
g_free(self->follow_filename);
g_static_mutex_free(&self->pending_proto_lock);
g_cond_free(self->pending_proto_cond);
log_source_free(s);
}
void
afsocket_sd_free(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
log_reader_options_destroy(&self->reader_options);
g_sockaddr_unref(self->bind_addr);
self->bind_addr = NULL;
g_free(self->transport);
#if ENABLE_SSL
if(self->tls_context)
{
tls_context_free(self->tls_context);
}
#endif
log_src_driver_free(s);
}
gpointer
threaded_feed(gpointer args)
{
LogQueue *q = args;
char *msg_str = "<155>2006-02-11T10:34:56+01:00 bzorp syslog-ng[23323]: árvíztűrőtükörfúrógép";
gint msg_len = strlen(msg_str);
gint i;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
LogMessage *msg, *tmpl;
GTimeVal start, end;
GSockAddr *sa;
glong diff;
iv_init();
/* emulate main loop for LogQueue */
main_loop_worker_thread_start(NULL);
sa = g_sockaddr_inet_new("10.10.10.10", 1010);
tmpl = log_msg_new(msg_str, msg_len, sa, &parse_options);
g_sockaddr_unref(sa);
g_get_current_time(&start);
for (i = 0; i < MESSAGES_PER_FEEDER; i++)
{
msg = log_msg_clone_cow(tmpl, &path_options);
log_msg_add_ack(msg, &path_options);
msg->ack_func = test_ack;
log_queue_push_tail(q, msg, &path_options);
if ((i & 0xFF) == 0)
main_loop_worker_invoke_batch_callbacks();
}
main_loop_worker_invoke_batch_callbacks();
g_get_current_time(&end);
diff = g_time_val_diff(&end, &start);
g_static_mutex_lock(&tlock);
sum_time += diff;
g_static_mutex_unlock(&tlock);
log_msg_unref(tmpl);
iv_deinit();
main_loop_worker_thread_stop();
return NULL;
}
static void
assert_hostname_to_sockaddr(gint family, const gchar *hostname, const gchar *expected_ip)
{
GSockAddr *sa = NULL;
gchar ip[64];
gboolean result;
result = resolve_hostname_to_sockaddr(&sa, family, hostname);
if (sa)
{
g_sockaddr_format(sa, ip, sizeof(ip), GSA_ADDRESS_ONLY);
g_sockaddr_unref(sa);
}
assert_true(result, "unexpected error return");
assert_true(sa != NULL, "sockaddr can't be NULL for successful returns");
assert_string(ip, expected_ip, "resolved address mismatch");
}
static void
log_reader_free(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (self->proto)
{
log_proto_server_free(self->proto);
self->proto = NULL;
}
if (self->poll_events)
poll_events_free(self->poll_events);
log_pipe_unref(self->control);
g_sockaddr_unref(self->peer_addr);
g_static_mutex_free(&self->pending_proto_lock);
g_cond_free(self->pending_proto_cond);
log_source_free(s);
}
LogMessage *
create_sample_message(void)
{
LogMessage *msg;
char *msg_str = "<155>2006-02-11T10:34:56+01:00 bzorp syslog-ng[23323]:árvíztűrőtükörfúrógép";
GSockAddr *saddr;
saddr = g_sockaddr_inet_new("10.11.12.13", 1010);
msg = log_msg_new(msg_str, strlen(msg_str), saddr, &parse_options);
g_sockaddr_unref(saddr);
log_msg_set_value_by_name(msg, "APP.VALUE", "value", -1);
log_msg_set_value_by_name(msg, "APP.STRIP1", " value", -1);
log_msg_set_value_by_name(msg, "APP.STRIP2", "value ", -1);
log_msg_set_value_by_name(msg, "APP.STRIP3", " value ", -1);
log_msg_set_value_by_name(msg, "APP.STRIP4", "value", -1);
log_msg_set_value_by_name(msg, "APP.STRIP5", "", -1);
log_msg_set_value_by_name(msg, "APP.QVALUE", "\"value\"", -1);
log_msg_set_value_by_name(msg, ".unix.uid", "1000", -1);
log_msg_set_value_by_name(msg, ".unix.gid", "1000", -1);
log_msg_set_value_by_name(msg, ".unix.cmd", "command", -1);
log_msg_set_value_by_name(msg, ".json.foo", "bar", -1);
log_msg_set_value_by_name(msg, ".json.sub.value1", "subvalue1", -1);
log_msg_set_value_by_name(msg, ".json.sub.value2", "subvalue2", -1);
log_msg_set_value_by_name(msg, "escaping", "binary stuff follows \"\xad árvíztűrőtükörfúrógép", -1);
log_msg_set_match(msg, 0, "whole-match", -1);
log_msg_set_match(msg, 1, "first-match", -1);
log_msg_set_tag_by_name(msg, "alma");
log_msg_set_tag_by_name(msg, "korte");
log_msg_clear_tag_by_name(msg, "narancs");
log_msg_set_tag_by_name(msg, "citrom");
msg->rcptid = 555;
/* fix some externally or automatically defined values */
log_msg_set_value(msg, LM_V_HOST_FROM, "kismacska", -1);
msg->timestamps[LM_TS_RECVD].tv_sec = 1139684315;
msg->timestamps[LM_TS_RECVD].tv_usec = 639000;
msg->timestamps[LM_TS_RECVD].zone_offset = get_local_timezone_ofs(1139684315);
return msg;
}
static gboolean
slng_send_cmd(gchar *cmd)
{
GSockAddr *saddr = NULL;
if (control_socket == -1)
{
saddr = g_sockaddr_unix_new(control_name);
control_socket = socket(PF_UNIX, SOCK_STREAM, 0);
if (control_socket == -1)
{
fprintf(stderr, "Error opening control socket, socket='%s', error='%s'\n", control_name, strerror(errno));
goto error;
}
if (g_connect(control_socket, saddr) != G_IO_STATUS_NORMAL)
{
fprintf(stderr, "Error connecting control socket, socket='%s', error='%s'\n", control_name, strerror(errno));
close(control_socket);
control_socket = -1;
goto error;
}
}
if (write(control_socket, cmd, strlen(cmd)) < 0)
{
fprintf(stderr, "Error sending command on control sokcet, socket='%s', cmd='%s', error='%s'\n", control_name, cmd, strerror(errno));
goto error;
}
return TRUE;
error:
if (saddr)
g_sockaddr_unref(saddr);
return FALSE;
}
static void
control_socket_accept(gpointer user_data)
{
gint conn_socket;
GSockAddr *peer_addr;
GIOStatus status;
if (control_socket == -1)
return;
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;
}
/* NOTE: the connection will free itself if the peer terminates */
control_connection_new(conn_socket);
g_sockaddr_unref(peer_addr);
error:
;
}
void
feed_some_messages(LogQueue **q, int n)
{
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
LogMessage *msg;
gint i;
path_options.ack_needed = (*q)->use_backlog;
for (i = 0; i < n; i++)
{
char *msg_str = "<155>2006-02-11T10:34:56+01:00 bzorp syslog-ng[23323]: árvíztűrőtükörfúrógép";
GSockAddr *sa;
sa = g_sockaddr_inet_new("10.10.10.10", 1010);
msg = log_msg_new(msg_str, strlen(msg_str), sa, &parse_options);
g_sockaddr_unref(sa);
log_msg_add_ack(msg, &path_options);
msg->ack_func = test_ack;
log_queue_push_tail((*q), msg, &path_options);
fed_messages++;
}
}
static void
control_socket_accept(void *cookie)
{
ControlServerUnix *self = (ControlServerUnix *)cookie;
gint conn_socket;
GSockAddr *peer_addr;
GIOStatus status;
if (self->control_socket == -1)
return;
status = g_accept(self->control_socket, &conn_socket, &peer_addr);
if (status != G_IO_STATUS_NORMAL)
{
msg_error("Error accepting control socket connection",
evt_tag_errno("error", errno));
goto error;
}
/* NOTE: the connection will free itself if the peer terminates */
control_connection_new(&self->super, conn_socket);
g_sockaddr_unref(peer_addr);
error:
;
}
int
testcase_match(const gchar *log, const gchar *pattern, gint matcher_flags, gboolean expected_result, LogMatcher *m)
{
LogMessage *msg;
gboolean result;
gchar buf[1024];
NVHandle nonasciiz = log_msg_get_value_handle("NON-ASCIIZ");
gssize msglen;
const gchar *value;
GSockAddr *sa;
sa = g_sockaddr_inet_new("10.10.10.10", 1010);
msg = log_msg_new(log, strlen(log), sa, &parse_options);
g_sockaddr_unref(sa);
g_snprintf(buf, sizeof(buf), "%sAAAAAAAAAAAA", log_msg_get_value(msg, LM_V_MESSAGE, &msglen));
log_msg_set_value(msg, log_msg_get_value_handle("MESSAGE2"), buf, -1);
/* add a non-zero terminated indirect value which contains the whole message */
log_msg_set_value_indirect(msg, nonasciiz, log_msg_get_value_handle("MESSAGE2"), 0, 0, msglen);
log_matcher_set_flags(m, matcher_flags);
log_matcher_compile(m, pattern);
value = log_msg_get_value(msg, nonasciiz, &msglen);
result = log_matcher_match(m, msg, nonasciiz, value, msglen);
if (result != expected_result)
{
fprintf(stderr, "Testcase match failure. pattern=%s, result=%d, expected=%d\n", pattern, result, expected_result);
exit(1);
}
log_matcher_unref(m);
log_msg_unref(msg);
return 0;
}