LogDriver *
afinet_dd_new(gint af, gchar *host, gint port, guint flags)
{
AFInetDestDriver *self = g_new0(AFInetDestDriver, 1);
afsocket_dd_init_instance(&self->super, &self->sock_options.super, flags, g_strdup(host), g_strdup_printf("%s:%d", host, port));
if (self->super.flags & AFSOCKET_DGRAM)
self->super.transport = g_strdup("udp");
else if (self->super.flags & AFSOCKET_STREAM)
self->super.transport = g_strdup("tcp");
self->super.super.super.init = afinet_dd_init;
self->super.super.super.queue = afinet_dd_queue;
self->super.super.super.free_fn = afinet_dd_free;
if (af == AF_INET)
{
self->super.bind_addr = g_sockaddr_inet_new("0.0.0.0", 0);
self->super.dest_addr = g_sockaddr_inet_new("0.0.0.0", port);
}
else
{
#if ENABLE_IPV6
self->super.bind_addr = g_sockaddr_inet6_new("::", 0);
self->super.dest_addr = g_sockaddr_inet6_new("::", port);
#else
g_assert_not_reached();
#endif
}
self->super.setup_socket = afinet_dd_setup_socket;
return &self->super.super;
}
static LogTransportAuxData *
construct_aux_with_some_data(void)
{
LogTransportAuxData *aux = construct_empty_aux();
/* set peer_addr twice to validate that peer_addr is correctly reference counted */
log_transport_aux_data_set_peer_addr_ref(aux, g_sockaddr_inet_new("1.2.3.4", 5555));
log_transport_aux_data_set_peer_addr_ref(aux, g_sockaddr_inet_new("1.2.3.4", 5555));
log_transport_aux_data_add_nv_pair(aux, "foo", "bar");
return aux;
}
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 (self->super.transport_mapper->address_family == AF_INET)
{
self->super.bind_addr = g_sockaddr_inet_new("0.0.0.0", 0);
self->super.dest_addr = g_sockaddr_inet_new("0.0.0.0", 0);
}
#if ENABLE_IPV6
else if (self->super.transport_mapper->address_family == AF_INET6)
{
self->super.bind_addr = g_sockaddr_inet6_new("::", 0);
self->super.dest_addr = g_sockaddr_inet6_new("::", 0);
}
#endif
else
{
/* address family not known */
g_assert_not_reached();
}
if ((self->bind_ip && !resolve_hostname(&self->super.bind_addr, self->bind_ip)))
return FALSE;
if (!resolve_hostname(&self->super.dest_addr, 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, transport_mapper_inet_get_server_port(self->super.transport_mapper));
}
else
g_sockaddr_set_port(self->super.dest_addr, afinet_lookup_service(self->super.transport_mapper, self->dest_port));
return TRUE;
}
loglinesType *
testcase_get_logmessages(gchar *logs)
{
int i, len;
loglinesType *self;
gchar **input_lines;
gchar *logline;
GSockAddr *addr = g_sockaddr_inet_new("10.10.10.10", 1010);
LogMessage *msg;
self = g_new(loglinesType, 1);
self->logmessages = g_ptr_array_sized_new(10);
self->num_of_logs = 0;
input_lines = g_strsplit(logs, "\n", 0);
for (i = 0; input_lines[i]; ++i)
{
logline = g_strdup_printf("Jul 29 06:25:41 vav zorp/inter_http[27940]: %s", input_lines[i]);
len = strlen(logline);
if (logline[len-1] == '\n')
logline[len-1] = 0;
msg = log_msg_new(logline, len, addr, &parse_options);
g_ptr_array_add(self->logmessages, msg);
++(self->num_of_logs);
g_free(logline);
}
msg_format_options_destroy(&parse_options);
return self;
}
LogDriver *
afinet_sd_new(gint af, gchar *host, gint port, guint flags)
{
AFInetSourceDriver *self = g_new0(AFInetSourceDriver, 1);
afsocket_sd_init_instance(&self->super, &self->sock_options.super, flags);
self->super.flags |= AFSOCKET_KEEP_ALIVE;
if (af == AF_INET)
{
self->super.bind_addr = g_sockaddr_inet_new("0.0.0.0", port);
if (!host)
host = "0.0.0.0";
}
else
{
#if ENABLE_IPV6
self->super.bind_addr = g_sockaddr_inet6_new("::", port);
if (!host)
host = "::";
#else
g_assert_not_reached();
#endif
}
afinet_resolve_name(self->super.bind_addr, host);
self->super.setup_socket = afinet_sd_setup_socket;
return &self->super.super;
}
gpointer
threaded_feed(gpointer st)
{
LogQueue *q = (LogQueue *) st;
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 i;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
LogMessage *msg;
for (i = 0; i < 100000; i++)
{
msg = log_msg_new(msg_str, strlen(msg_str), g_sockaddr_inet_new("10.10.10.10", 1010), 0, NULL, -1);
log_msg_add_ack(msg, &path_options);
msg->ack_func = test_ack;
g_static_mutex_lock(&threaded_lock);
if (!log_queue_push_tail(q, msg, &path_options))
{
fprintf(stderr, "Queue unable to consume enough messages: %d\n", fed_messages);
return GUINT_TO_POINTER(1);
}
g_static_mutex_unlock(&threaded_lock);
}
return NULL;
}
LogMessage *
parse_log_message(gchar *raw_message_str, gint parse_flags, gchar *bad_hostname_re)
{
LogMessage *message;
GSockAddr *addr = g_sockaddr_inet_new("10.10.10.10", 1010);
regex_t bad_hostname;
parse_options.flags = parse_flags;
parse_options.sdata_param_value_max = 255;
if (bad_hostname_re)
{
assert_gint(regcomp(&bad_hostname, bad_hostname_re, REG_NOSUB | REG_EXTENDED), 0,
"Unexpected failure of regcomp(); bad_hostname_re='%s'", bad_hostname_re);
parse_options.bad_hostname = &bad_hostname;
}
message = log_msg_new(raw_message_str, strlen(raw_message_str), addr, &parse_options);
if (bad_hostname_re)
{
regfree(parse_options.bad_hostname);
parse_options.bad_hostname = NULL;
}
simulate_log_readers_effect_on_timezone_offset(message);
return message;
}
LogMessage *
create_empty_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_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;
msg->host_id = 0xcafebabe;
/* 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;
}
void
test_cloning_with_log_message(gchar *msg)
{
LogMessage *original_log_message, *log_message, *cloned_log_message;
regex_t bad_hostname;
GSockAddr *addr = g_sockaddr_inet_new("10.10.10.10", 1010);
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
testcase_begin("Testing log message cloning; msg='%s'", msg);
parse_options.flags = LP_SYSLOG_PROTOCOL;
parse_options.bad_hostname = &bad_hostname;
original_log_message = log_msg_new(msg, strlen(msg), addr, &parse_options);
log_message = log_msg_new(msg, strlen(msg), addr, &parse_options);
log_msg_set_tag_by_name(log_message, "newtag");
path_options.ack_needed = FALSE;
cloned_log_message = log_msg_clone_cow(log_message, &path_options);
assert_log_messages_equal(cloned_log_message, original_log_message);
set_new_log_message_attributes(cloned_log_message);
assert_log_messages_equal(log_message, original_log_message);
assert_new_log_message_attributes(cloned_log_message);
assert_log_message_has_tag(cloned_log_message, "newtag");
log_msg_unref(cloned_log_message);
log_msg_unref(log_message);
log_msg_unref(original_log_message);
testcase_end();
}
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;
}
gssize
log_transport_mock_read_method(LogTransport *s, gpointer buf, gsize count, LogTransportAuxData *aux)
{
LogTransportMock *self = (LogTransportMock *) s;
struct iovec *current_iov;
if (self->current_iov_ndx >= self->iov_cnt)
{
count = 0;
goto exit;
}
current_iov = &self->iov[self->current_iov_ndx];
if (self->inject_eagain)
{
self->inject_eagain = FALSE;
errno = EAGAIN;
return -1;
}
else
{
self->inject_eagain = TRUE;
}
if (self->input_is_a_stream)
count = 1;
if (count + self->current_iov_pos > current_iov->iov_len)
count = current_iov->iov_len - self->current_iov_pos;
if (GPOINTER_TO_UINT(current_iov->iov_base) < 4096)
{
/* error injection */
errno = GPOINTER_TO_UINT(current_iov->iov_base);
return -1;
}
memcpy(buf, current_iov->iov_base + self->current_iov_pos, count);
self->current_iov_pos += count;
if (self->current_iov_pos >= current_iov->iov_len)
{
self->current_iov_pos = 0;
self->current_iov_ndx++;
}
if (aux)
aux->peer_addr = g_sockaddr_inet_new("1.2.3.4", 5555);
exit:
if (count == 0 && self->eof_is_eagain)
{
errno = EAGAIN;
return -1;
}
return count;
}
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;
}
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;
}
LogMessage *
construct_log_message_with_all_bells_and_whistles(void)
{
LogMessage *msg = construct_log_message();
nv_handle = log_msg_get_value_handle("foo");
sd_handle = log_msg_get_value_handle(".SDATA.foo.bar");
log_msg_set_value(msg, nv_handle, "value", -1);
log_msg_set_value(msg, sd_handle, "value", -1);
msg->saddr = g_sockaddr_inet_new("1.2.3.4", 5050);
log_msg_set_tag_by_name(msg, tag_name);
return msg;
}
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;
}
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;
}
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++;
}
}
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;
}
int
stomp_connect(stomp_connection **connection_ref, char *hostname, int port)
{
stomp_connection *conn;
conn = g_new0(stomp_connection, 1);
conn->socket = socket(AF_INET, SOCK_STREAM, 0);
if (conn->socket == -1)
{
msg_error("Failed to create socket!", NULL);
return FALSE;
}
conn->remote_sa = g_sockaddr_inet_new("127.0.0.1", port);
if (!resolve_hostname(&conn->remote_sa, hostname))
{
msg_error("Failed to resolve hostname in stomp driver",
evt_tag_str("hostname", hostname),
NULL);
return FALSE;
}
if (!g_connect(conn->socket, conn->remote_sa))
{
msg_error("Stomp connection failed",
evt_tag_str("host", hostname),
NULL);
_stomp_connection_free(conn);
return FALSE;
}
(*connection_ref) = conn;
return TRUE;
};
void
feed_some_messages(LogQueue **q, int n, gboolean flow_control)
{
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
LogMessage *msg;
gint i;
path_options.flow_control = flow_control;
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";
msg = log_msg_new(msg_str, strlen(msg_str), g_sockaddr_inet_new("10.10.10.10", 1010), 0, NULL, -1, 0xFFFF);
log_msg_add_ack(msg, &path_options);
msg->ack_func = test_ack;
if (!log_queue_push_tail((*q), msg, &path_options))
{
fprintf(stderr, "Queue unable to consume enough messages: %d\n", fed_messages);
exit(1);
}
fed_messages++;
}
}
LogMessage *
init_msg(gchar *msg_string, gboolean use_syslog_protocol)
{
LogMessage *msg;
GSockAddr *sa;
if (use_syslog_protocol)
parse_options.flags |= LP_SYSLOG_PROTOCOL;
else
parse_options.flags &= ~LP_SYSLOG_PROTOCOL;
sa = g_sockaddr_inet_new("10.10.10.10", 1010);
msg = log_msg_new(msg_string, strlen(msg_string), sa, &parse_options);
g_sockaddr_unref(sa);
log_msg_set_value_by_name(msg, "APP.VALUE", "value", 5);
log_msg_set_match(msg, 0, "whole-match", 11);
log_msg_set_match(msg, 1, "first-match", 11);
/* fix some externally or automatically defined values */
log_msg_set_value(msg, LM_V_HOST_FROM, "kismacska", 9);
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 void
assert_ip_to_fqdn_hostname(const gchar *ip, const gchar *expected)
{
host_resolve_options.use_fqdn = TRUE;
assert_sockaddr_to_hostname(g_sockaddr_inet_new(ip, 0), expected);
}
static gboolean
afinet_dd_apply_transport(AFSocketDestDriver *s)
{
AFInetDestDriver *self = (AFInetDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(&s->super.super.super);
gchar *default_dest_port = NULL;
struct protoent *ipproto_ent;
g_sockaddr_unref(self->super.bind_addr);
g_sockaddr_unref(self->super.dest_addr);
if (self->super.address_family == AF_INET)
{
self->super.bind_addr = g_sockaddr_inet_new("0.0.0.0", 0);
self->super.dest_addr = g_sockaddr_inet_new("0.0.0.0", 0);
}
#if ENABLE_IPV6
else if (self->super.address_family == AF_INET6)
{
self->super.bind_addr = g_sockaddr_inet6_new("::", 0);
self->super.dest_addr = g_sockaddr_inet6_new("::", 0);
}
#endif
else
{
/* address family not known */
g_assert_not_reached();
}
if (self->super.transport == NULL)
{
if (self->super.sock_type == SOCK_STREAM)
afsocket_dd_set_transport(&self->super.super.super, "tcp");
else
afsocket_dd_set_transport(&self->super.super.super, "udp");
}
if (strcasecmp(self->super.transport, "udp") == 0)
{
static gboolean msg_udp_source_port_warning = FALSE;
if (!self->dest_port)
{
/* NOTE: this version number change has happened in a different
* major version in OSE vs. PE, thus the update behaviour must
* be triggered differently. In OSE it needs to be triggered
* when the config version has changed to 3.3, in PE when 3.2.
*
* This is unfortunate, the only luck we have to be less
* confusing is that syslog() driver was seldom used.
*
*/
if (self->super.syslog_protocol && cfg_is_config_version_older(cfg, 0x0303))
{
if (!msg_udp_source_port_warning)
{
msg_warning("WARNING: Default port for syslog(transport(udp)) has changed from 601 to 514 in syslog-ng 3.3, please update your configuration",
evt_tag_str("id", self->super.super.super.id),
NULL);
msg_udp_source_port_warning = TRUE;
}
default_dest_port = "601";
}
else
default_dest_port = "514";
}
self->super.sock_type = SOCK_DGRAM;
self->super.sock_protocol = 0;
self->super.logproto_name = "dgram";
}
else if (strcasecmp(self->super.transport, "tcp") == 0)
{
if (self->super.syslog_protocol)
{
self->super.logproto_name = "framed";
default_dest_port = "601";
}
else
{
self->super.logproto_name = "text";
default_dest_port = "514";
}
self->super.sock_type = SOCK_STREAM;
self->super.sock_protocol = 0;
}
else if (strcasecmp(self->super.transport, "tls") == 0)
{
static gboolean msg_tls_source_port_warning = FALSE;
g_assert(self->super.syslog_protocol);
if (!self->dest_port)
{
/* NOTE: this version number change has happened in a different
* major version in OSE vs. PE, thus the update behaviour must
* be triggered differently. In OSE it needs to be triggered
* when the config version has changed to 3.3, in PE when 3.2.
*
* This is unfortunate, the only luck we have to be less
* confusing is that syslog() driver was seldom used.
*
*/
if (cfg_is_config_version_older(cfg, 0x0303))
{
if (!msg_tls_source_port_warning)
{
msg_warning("WARNING: Default port for syslog(transport(tls)) is modified from 601 to 6514",
evt_tag_str("id", self->super.super.super.id),
NULL);
msg_tls_source_port_warning = TRUE;
}
default_dest_port = "601";
}
else
default_dest_port = "6514";
}
self->super.require_tls = TRUE;
self->super.sock_type = SOCK_STREAM;
self->super.logproto_name = "framed";
}
else
{
self->super.sock_type = SOCK_STREAM;
self->super.logproto_name = self->super.transport;
}
if ((self->bind_ip && !resolve_hostname(&self->super.bind_addr, self->bind_ip)))
return FALSE;
if (!self->super.sock_protocol)
{
if (self->super.sock_type == SOCK_STREAM)
self->super.sock_protocol = IPPROTO_TCP;
else
self->super.sock_protocol = IPPROTO_UDP;
}
ipproto_ent = getprotobynumber(self->super.sock_protocol);
afinet_set_port(self->super.dest_addr, self->dest_port ? : default_dest_port,
ipproto_ent ? ipproto_ent->p_name
: (self->super.sock_type == SOCK_STREAM) ? "tcp" : "udp");
if (!self->super.dest_name)
self->super.dest_name = g_strdup_printf("%s:%d", self->super.hostname,
g_sockaddr_inet_check(self->super.dest_addr) ? g_sockaddr_inet_get_port(self->super.dest_addr)
#if ENABLE_IPV6
: g_sockaddr_inet6_get_port(self->super.dest_addr)
#else
: 0
#endif
);
#if BUILD_WITH_SSL
if (self->super.require_tls && !self->super.tls_context)
{
msg_error("transport(tls) was specified, but tls() options missing",
evt_tag_str("id", self->super.super.super.id),
NULL);
return FALSE;
}
#endif
return TRUE;
}
int
testcase(gchar *msg,
gint parse_flags, /* LP_NEW_PROTOCOL */
gchar *bad_hostname_re,
gint expected_pri,
guint expected_version,
unsigned long expected_stamps_sec,
unsigned long expected_stamps_usec,
unsigned long expected_stamps_ofs,
const gchar *expected_host,
const gchar *expected_msg,
const gchar *expected_program,
const gchar *expected_sd_str,
const gchar *expected_process_id,
const gchar *expected_message_id
)
{
LogMessage *logmsg, *cloned;
time_t now;
regex_t bad_hostname;
GSockAddr *addr = g_sockaddr_inet_new("10.10.10.10", 1010);
gchar logmsg_addr[256], cloned_addr[256];
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
GString *sd_str = g_string_sized_new(0);
if (bad_hostname_re)
TEST_ASSERT(regcomp(&bad_hostname, bad_hostname_re, REG_NOSUB | REG_EXTENDED) == 0, "%d", 0, 0);
parse_options.flags = parse_flags;
parse_options.bad_hostname = &bad_hostname;
logmsg = log_msg_new(msg, strlen(msg), addr, &parse_options);
TEST_ASSERT(logmsg->pri == expected_pri, "%d", logmsg->pri, expected_pri);
if (expected_stamps_sec)
{
if (expected_stamps_sec != 1)
{
TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_sec == expected_stamps_sec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_sec, (int) expected_stamps_sec);
}
TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_usec == expected_stamps_usec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_usec, (int) expected_stamps_usec);
TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].zone_offset == expected_stamps_ofs, "%d", (int) logmsg->timestamps[LM_TS_STAMP].zone_offset, (int) expected_stamps_ofs);
}
else
{
time(&now);
TEST_ASSERT(absolute_value(logmsg->timestamps[LM_TS_STAMP].time.tv_sec - now) < 1, "%d", 0, 0);
}
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host) == 0, "%s", log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program) == 0, "%s", log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg) == 0, "%s", log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id);
/* SD elements */
log_msg_format_sdata(logmsg, sd_str);
TEST_ASSERT(strcmp(sd_str->str, expected_sd_str) == 0, "%s", sd_str->str, expected_sd_str);
/* check if the sockaddr matches */
g_sockaddr_format(logmsg->saddr, logmsg_addr, sizeof(logmsg_addr), GSA_FULL);
path_options.flow_control = FALSE;
cloned = log_msg_clone_cow(logmsg, &path_options);
g_sockaddr_format(cloned->saddr, cloned_addr, sizeof(cloned_addr), GSA_FULL);
TEST_ASSERT(strcmp(logmsg_addr, cloned_addr) == 0, "%s", cloned_addr, logmsg_addr);
TEST_ASSERT(logmsg->pri == cloned->pri, "%d", logmsg->pri, cloned->pri);
TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_sec == cloned->timestamps[LM_TS_STAMP].time.tv_sec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_sec, (int) cloned->timestamps[LM_TS_STAMP].time.tv_sec);
TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_usec == cloned->timestamps[LM_TS_STAMP].time.tv_usec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_usec, (int) cloned->timestamps[LM_TS_STAMP].time.tv_usec);
TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].zone_offset == cloned->timestamps[LM_TS_STAMP].zone_offset, "%d", (int) logmsg->timestamps[LM_TS_STAMP].zone_offset, (int) cloned->timestamps[LM_TS_STAMP].zone_offset);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_HOST, NULL), log_msg_get_value(cloned, LM_V_HOST, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_HOST, NULL), log_msg_get_value(cloned, LM_V_HOST, NULL));
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), log_msg_get_value(cloned, LM_V_PROGRAM, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), log_msg_get_value(cloned, LM_V_PROGRAM, NULL));
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), log_msg_get_value(cloned, LM_V_MESSAGE, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), log_msg_get_value(cloned, LM_V_MESSAGE, NULL));
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PID, NULL), log_msg_get_value(cloned, LM_V_PID, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_PID, NULL), log_msg_get_value(cloned, LM_V_PID, NULL));
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MSGID, NULL), log_msg_get_value(cloned, LM_V_MSGID, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_MSGID, NULL), log_msg_get_value(cloned, LM_V_MSGID, NULL));
/* SD elements */
log_msg_format_sdata(cloned, sd_str);
TEST_ASSERT(strcmp(sd_str->str, expected_sd_str) == 0, "%s", sd_str->str, expected_sd_str);
log_msg_set_value(cloned, LM_V_HOST, "newhost", -1);
log_msg_set_value(cloned, LM_V_HOST_FROM, "newhost", -1);
log_msg_set_value(cloned, LM_V_MESSAGE, "newmsg", -1);
log_msg_set_value(cloned, LM_V_PROGRAM, "newprogram", -1);
log_msg_set_value(cloned, LM_V_PID, "newpid", -1);
log_msg_set_value(cloned, LM_V_MSGID, "newmsgid", -1);
log_msg_set_value(cloned, LM_V_SOURCE, "newsource", -1);
log_msg_set_value(cloned, log_msg_get_value_handle("newvalue"), "newvalue", -1);
/* retest values in original logmsg */
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host) == 0, "%s", log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program) == 0, "%s", log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg) == 0, "%s", log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id);
TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_SOURCE, NULL), "") == 0, "%s", log_msg_get_value(logmsg, LM_V_SOURCE, NULL), "");
/* check newly set values in cloned */
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_HOST, NULL), "newhost") == 0, "%s", log_msg_get_value(cloned, LM_V_HOST, NULL), "newhost");
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_HOST_FROM, NULL), "newhost") == 0, "%s", log_msg_get_value(cloned, LM_V_HOST_FROM, NULL), "newhost");
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_PROGRAM, NULL), "newprogram") == 0, "%s", log_msg_get_value(cloned, LM_V_PROGRAM, NULL), "newprogram");
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_MESSAGE, NULL), "newmsg") == 0, "%s", log_msg_get_value(cloned, LM_V_MESSAGE, NULL), "newmsg");
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_PID, NULL), "newpid") == 0, "%s", log_msg_get_value(cloned, LM_V_PID, NULL), "newpid");
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_MSGID, NULL), "newmsgid") == 0, "%s", log_msg_get_value(cloned, LM_V_MSGID, NULL), "newmsgid");
TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_SOURCE, NULL), "newsource") == 0, "%s", log_msg_get_value(cloned, LM_V_SOURCE, NULL), "newsource");
log_msg_unref(cloned);
log_msg_unref(logmsg);
g_string_free(sd_str, TRUE);
return 0;
}
