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_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;
}
static gboolean
afsocket_sd_process_connection(AFSocketSourceDriver *self, GSockAddr *client_addr, GSockAddr *local_addr, gint fd)
{
gchar buf[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
#if SYSLOG_NG_ENABLE_TCP_WRAPPER
if (client_addr && (client_addr->sa.sa_family == AF_INET
#if SYSLOG_NG_ENABLE_IPV6
|| client_addr->sa.sa_family == AF_INET6
#endif
))
{
struct request_info req;
request_init(&req, RQ_DAEMON, "syslog-ng", RQ_FILE, fd, 0);
fromhost(&req);
if (hosts_access(&req) == 0)
{
msg_error("Syslog connection rejected by tcpd",
evt_tag_str("client", g_sockaddr_format(client_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(local_addr, buf2, sizeof(buf2), GSA_FULL)),
NULL);
return FALSE;
}
}
#endif
if (self->num_connections >= self->max_connections)
{
msg_error("Number of allowed concurrent connections reached, rejecting connection",
evt_tag_str("client", g_sockaddr_format(client_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_str("local", g_sockaddr_format(local_addr, buf2, sizeof(buf2), GSA_FULL)),
evt_tag_int("max", self->max_connections),
NULL);
return FALSE;
}
else
{
AFSocketSourceConnection *conn;
conn = afsocket_sc_new(client_addr, fd, self->super.super.super.cfg);
afsocket_sc_set_owner(conn, self);
if (log_pipe_init(&conn->super))
{
afsocket_sd_add_connection(self, conn);
self->num_connections++;
log_pipe_append(&conn->super, &self->super.super.super);
}
else
{
log_pipe_unref(&conn->super);
return FALSE;
}
}
return TRUE;
}
void
assert_log_messages_saddr(LogMessage *log_message_a, LogMessage *log_message_b)
{
gchar address_a[256], address_b[256];
g_sockaddr_format(log_message_a->saddr, address_a, sizeof(address_a), GSA_FULL);
g_sockaddr_format(log_message_b->saddr, address_b, sizeof(address_b), GSA_FULL);
assert_string(address_a, address_b, "Socket address is not expected");
}
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 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 void
afsocket_dd_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data)
{
AFSocketDestDriver *self = (AFSocketDestDriver *) s;
gchar buf[MAX_SOCKADDR_STRING];
switch (notify_code)
{
case NC_CLOSE:
case NC_WRITE_ERROR:
log_writer_reopen(self->writer, NULL);
msg_notice("Syslog connection broken",
evt_tag_int("fd", self->fd),
evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_int("time_reopen", self->time_reopen),
NULL);
if (self->reconnect_timer)
{
g_source_remove(self->reconnect_timer);
self->reconnect_timer = 0;
}
self->reconnect_timer = g_timeout_add(self->time_reopen * 1000, afsocket_dd_reconnect_timer, self);
break;
}
}
static inline gchar *
afsocket_sd_format_persist_name(AFSocketSourceDriver *self, gboolean listener_name)
{
static gchar persist_name[128];
gchar buf[64];
g_snprintf(persist_name, sizeof(persist_name),
listener_name ? "afsocket_sd_listen_fd(%s,%s)" : "afsocket_sd_connections(%s,%s)",
(self->transport_mapper->sock_type == SOCK_STREAM) ? "stream" : "dgram",
g_sockaddr_format(self->bind_addr, buf, sizeof(buf), GSA_FULL));
return persist_name;
}
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 gchar *
afsocket_sc_stats_instance(AFSocketSourceConnection *self)
{
static gchar buf[256];
if (!self->peer_addr)
{
return NULL;
}
if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
{
g_sockaddr_format(self->peer_addr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
}
else
{
gchar peer_addr[MAX_SOCKADDR_STRING];
g_sockaddr_format(self->peer_addr, peer_addr, sizeof(peer_addr), GSA_ADDRESS_ONLY);
g_snprintf(buf, sizeof(buf), "%s,%s", self->owner->transport, peer_addr);
}
return buf;
}
static gchar *
afsocket_sc_stats_instance(AFSocketSourceConnection *self)
{
static gchar buf[256];
gchar peer_addr[MAX_SOCKADDR_STRING];
if (!self->peer_addr)
{
/* dgram connection, which means we have no peer, use the bind address */
if (self->owner->bind_addr)
{
g_sockaddr_format(self->owner->bind_addr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
return buf;
}
else
return NULL;
}
g_sockaddr_format(self->peer_addr, peer_addr, sizeof(peer_addr), GSA_ADDRESS_ONLY);
g_snprintf(buf, sizeof(buf), "%s,%s", self->owner->transport_mapper->transport, peer_addr);
return buf;
}
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");
}
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 const gchar *
resolve_sockaddr_to_inet_or_inet6_hostname(gsize *result_len, GSockAddr *saddr,
const HostResolveOptions *host_resolve_options)
{
const gchar *hname;
gsize hname_len;
gboolean positive;
void *dnscache_key;
dnscache_key = sockaddr_to_dnscache_key(saddr);
hname = NULL;
positive = FALSE;
if (host_resolve_options->use_dns_cache)
{
if (dns_caching_lookup(saddr->sa.sa_family, dnscache_key, (const gchar **) &hname, &hname_len, &positive))
return hostname_apply_options_fqdn(hname_len, result_len, hname, positive, host_resolve_options);
}
if (!hname && host_resolve_options->use_dns && host_resolve_options->use_dns != 2)
{
#ifdef SYSLOG_NG_HAVE_GETNAMEINFO
hname = resolve_address_using_getnameinfo(saddr, hostname_buffer, sizeof(hostname_buffer));
#else
hname = resolve_address_using_gethostbyaddr(saddr, hostname_buffer, sizeof(hostname_buffer));
#endif
positive = (hname != NULL);
}
if (!hname)
{
hname = g_sockaddr_format(saddr, hostname_buffer, sizeof(hostname_buffer), GSA_ADDRESS_ONLY);
positive = FALSE;
}
if (host_resolve_options->use_dns_cache)
dns_caching_store(saddr->sa.sa_family, dnscache_key, hname, positive);
return hostname_apply_options_fqdn(-1, result_len, hname, positive, host_resolve_options);
}
static gboolean
afsocket_sc_init(LogPipe *s)
{
AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
gint read_flags;
LogTransport *transport;
LogProto *proto;
gchar buf[256];
read_flags = ((self->owner->flags & AFSOCKET_DGRAM) ? LTF_RECV : 0);
#if ENABLE_SSL
if (self->owner->tls_context)
{
TLSSession *tls_session = tls_context_setup_session(self->owner->tls_context);
if (!tls_session)
return FALSE;
transport = log_transport_tls_new(tls_session, self->sock, read_flags);
}
else
#endif
transport = log_transport_plain_new(self->sock, read_flags, self->peer_addr == NULL ? NULL : g_sockaddr_format(self->peer_addr, buf, sizeof(buf), GSA_FULL));
if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
{
/* plain protocol */
if (self->owner->flags & AFSOCKET_DGRAM)
proto = log_proto_dgram_server_new(transport, self->owner->reader_options.msg_size, 0);
else if (self->owner->reader_options.padding)
proto = log_proto_record_server_new(transport, self->owner->reader_options.padding, 0);
else
proto = log_proto_text_server_new(transport, self->owner->reader_options.msg_size, 0);
}
else
{
if (self->owner->flags & AFSOCKET_DGRAM)
{
/* plain protocol */
proto = log_proto_dgram_server_new(transport, self->owner->reader_options.msg_size, 0);
}
else
{
/* framed protocol */
proto = log_proto_framed_server_new(transport, self->owner->reader_options.msg_size);
}
}
self->reader = log_reader_new(proto);
log_reader_set_options(self->reader, s, &self->owner->reader_options, 1, afsocket_sc_stats_source(self), self->owner->super.id, afsocket_sc_stats_instance(self));
log_reader_set_peer_addr(self->reader, self->peer_addr);
log_pipe_append(self->reader, s);
if (log_pipe_init(self->reader, NULL))
{
self->owner->connections = g_list_prepend(self->owner->connections, self);
return TRUE;
}
else
{
log_pipe_unref(self->reader);
self->reader = NULL;
}
return FALSE;
}
gboolean
log_macro_expand(GString *result, gint id, gboolean escape, const LogTemplateOptions *opts, gint tz, gint32 seq_num,
const gchar *context_id, const LogMessage *msg)
{
switch (id)
{
case M_FACILITY:
{
/* facility */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_FACMASK, sl_facilities);
if (n)
{
g_string_append(result, n);
}
else
{
format_uint32_padded(result, 0, 0, 16, (msg->pri & LOG_FACMASK) >> 3);
}
break;
}
case M_FACILITY_NUM:
{
format_uint32_padded(result, 0, 0, 10, (msg->pri & LOG_FACMASK) >> 3);
break;
}
case M_LEVEL:
{
/* level */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_PRIMASK, sl_levels);
if (n)
{
g_string_append(result, n);
}
else
{
format_uint32_padded(result, 0, 0, 10, msg->pri & LOG_PRIMASK);
}
break;
}
case M_LEVEL_NUM:
{
format_uint32_padded(result, 0, 0, 10, msg->pri & LOG_PRIMASK);
break;
}
case M_TAG:
{
format_uint32_padded(result, 2, '0', 16, msg->pri);
break;
}
case M_TAGS:
{
log_msg_print_tags(msg, result);
break;
}
case M_BSDTAG:
{
format_uint32_padded(result, 0, 0, 10, (msg->pri & LOG_PRIMASK));
g_string_append_c(result, (((msg->pri & LOG_FACMASK) >> 3) + 'A'));
break;
}
case M_PRI:
{
format_uint32_padded(result, 0, 0, 10, msg->pri);
break;
}
case M_HOST:
{
if (msg->flags & LF_CHAINED_HOSTNAME)
{
/* host */
const gchar *p1, *p2;
int remaining, length;
gssize host_len;
const gchar *host = log_msg_get_value(msg, LM_V_HOST, &host_len);
p1 = memchr(host, '@', host_len);
if (p1)
p1++;
else
p1 = host;
remaining = host_len - (p1 - host);
p2 = memchr(p1, '/', remaining);
length = p2 ? p2 - p1
: host_len - (p1 - host);
result_append(result, p1, length, escape);
}
else
{
_result_append_value(result, msg, LM_V_HOST, escape);
}
break;
}
case M_SDATA:
if (escape)
{
GString *sdstr = g_string_sized_new(0);
log_msg_append_format_sdata(msg, sdstr, seq_num);
result_append(result, sdstr->str, sdstr->len, TRUE);
g_string_free(sdstr, TRUE);
}
else
{
log_msg_append_format_sdata(msg, result, seq_num);
}
break;
case M_MSGHDR:
{
gssize len;
const gchar *p;
p = log_msg_get_value(msg, LM_V_LEGACY_MSGHDR, &len);
if (len > 0)
result_append(result, p, len, escape);
else
{
/* message, complete with program name and pid */
len = result->len;
_result_append_value(result, msg, LM_V_PROGRAM, escape);
if (len != result->len)
{
const gchar *pid = log_msg_get_value(msg, LM_V_PID, &len);
if (len > 0)
{
result_append(result, "[", 1, FALSE);
result_append(result, pid, len, escape);
result_append(result, "]", 1, FALSE);
}
result_append(result, ": ", 2, FALSE);
}
}
break;
}
case M_MESSAGE:
_result_append_value(result, msg, LM_V_MESSAGE, escape);
break;
case M_SOURCE_IP:
{
gchar *ip;
gchar buf[MAX_SOCKADDR_STRING];
if (_is_message_source_an_ip_address(msg))
{
g_sockaddr_format(msg->saddr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
ip = buf;
}
else
{
ip = "127.0.0.1";
}
result_append(result, ip, strlen(ip), escape);
break;
}
case M_SEQNUM:
{
if (seq_num)
{
format_uint32_padded(result, 0, 0, 10, seq_num);
}
break;
}
case M_CONTEXT_ID:
{
if (context_id)
{
result_append(result, context_id, strlen(context_id), escape);
}
break;
}
case M_RCPTID:
{
rcptid_append_formatted_id(result, msg->rcptid);
break;
}
case M_RUNID:
{
run_id_append_formatted_id(result);
break;
}
case M_HOSTID:
{
host_id_append_formatted_id(result, msg->host_id);
break;
}
case M_UNIQID:
{
if (msg->rcptid)
{
host_id_append_formatted_id(result, msg->host_id);
g_string_append(result, "@");
format_uint64_padded(result, 16, '0', 16, msg->rcptid);
break;
}
break;
}
case M_LOGHOST:
{
const gchar *hname = get_local_hostname_fqdn();
result_append(result, hname, -1, escape);
break;
}
case M_SYSUPTIME:
{
GTimeVal ct;
g_get_current_time(&ct);
format_uint64_padded(result, 0, 0, 10, g_time_val_diff(&ct, &app_uptime) / 1000 / 10);
break;
}
default:
{
/* year, month, day */
gchar buf[64];
gint length;
const UnixTime *stamp;
UnixTime sstamp;
guint tmp_hour;
if (id >= M_TIME_FIRST && id <= M_TIME_LAST)
{
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_RECVD_OFS && id <= M_TIME_LAST + M_RECVD_OFS)
{
id -= M_RECVD_OFS;
stamp = &msg->timestamps[LM_TS_RECVD];
}
else if (id >= M_TIME_FIRST + M_STAMP_OFS && id <= M_TIME_LAST + M_STAMP_OFS)
{
id -= M_STAMP_OFS;
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_CSTAMP_OFS && id <= M_TIME_LAST + M_CSTAMP_OFS)
{
id -= M_CSTAMP_OFS;
unix_time_set_now(&sstamp);
stamp = &sstamp;
}
else if (id >= M_TIME_FIRST + M_PROCESSED_OFS && id <= M_TIME_LAST + M_PROCESSED_OFS)
{
id -= M_PROCESSED_OFS;
stamp = &msg->timestamps[LM_TS_PROCESSED];
if (!unix_time_is_set(stamp))
{
unix_time_set_now(&sstamp);
stamp = &sstamp;
}
}
else
{
g_assert_not_reached();
break;
}
/* try to use the following zone values in order:
* destination specific timezone, if one is specified
* message specific timezone, if one is specified
* local timezone
*/
WallClockTime wct;
convert_unix_time_to_wall_clock_time_with_tz_override(stamp, &wct,
time_zone_info_get_offset(opts->time_zone_info[tz], stamp->ut_sec));
switch (id)
{
case M_WEEK_DAY_ABBREV:
g_string_append_len(result, weekday_names_abbrev[wct.wct_wday], 3);
break;
case M_WEEK_DAY_NAME:
g_string_append(result, weekday_names[wct.wct_wday]);
break;
case M_WEEK_DAY:
format_uint32_padded(result, 0, 0, 10, wct.wct_wday + 1);
break;
case M_WEEK:
format_uint32_padded(result, 2, '0', 10, (wct.wct_yday - (wct.wct_wday - 1 + 7) % 7 + 7) / 7);
break;
case M_YEAR:
format_uint32_padded(result, 4, '0', 10, wct.wct_year + 1900);
break;
case M_YEAR_DAY:
format_uint32_padded(result, 3, '0', 10, wct.wct_yday + 1);
break;
case M_MONTH:
format_uint32_padded(result, 2, '0', 10, wct.wct_mon + 1);
break;
case M_MONTH_WEEK:
format_uint32_padded(result, 0, 0, 10, ((wct.wct_mday / 7) +
((wct.wct_wday > 0) &&
((wct.wct_mday % 7) >= wct.wct_wday))));
break;
case M_MONTH_ABBREV:
g_string_append_len(result, month_names_abbrev[wct.wct_mon], 3);
break;
case M_MONTH_NAME:
g_string_append(result, month_names[wct.wct_mon]);
break;
case M_DAY:
format_uint32_padded(result, 2, '0', 10, wct.wct_mday);
break;
case M_HOUR:
format_uint32_padded(result, 2, '0', 10, wct.wct_hour);
break;
case M_HOUR12:
if (wct.wct_hour < 12)
tmp_hour = wct.wct_hour;
else
tmp_hour = wct.wct_hour - 12;
if (tmp_hour == 0)
tmp_hour = 12;
format_uint32_padded(result, 2, '0', 10, tmp_hour);
break;
case M_MIN:
format_uint32_padded(result, 2, '0', 10, wct.wct_min);
break;
case M_SEC:
format_uint32_padded(result, 2, '0', 10, wct.wct_sec);
break;
case M_MSEC:
format_uint32_padded(result, 3, '0', 10, stamp->ut_usec/1000);
break;
case M_USEC:
format_uint32_padded(result, 6, '0', 10, stamp->ut_usec);
break;
case M_AMPM:
g_string_append(result, wct.wct_hour < 12 ? "AM" : "PM");
break;
case M_DATE:
append_format_wall_clock_time(&wct, result, TS_FMT_BSD, opts->frac_digits);
break;
case M_STAMP:
if (opts->ts_format == TS_FMT_UNIX)
append_format_unix_time(stamp, result, TS_FMT_UNIX, wct.wct_gmtoff, opts->frac_digits);
else
append_format_wall_clock_time(&wct, result, opts->ts_format, opts->frac_digits);
break;
case M_ISODATE:
append_format_wall_clock_time(&wct, result, TS_FMT_ISO, opts->frac_digits);
break;
case M_FULLDATE:
append_format_wall_clock_time(&wct, result, TS_FMT_FULL, opts->frac_digits);
break;
case M_UNIXTIME:
append_format_unix_time(stamp, result, TS_FMT_UNIX, wct.wct_gmtoff, opts->frac_digits);
break;
case M_TZ:
case M_TZOFFSET:
length = format_zone_info(buf, sizeof(buf), wct.wct_gmtoff);
g_string_append_len(result, buf, length);
break;
default:
g_assert_not_reached();
break;
}
break;
}
}
return TRUE;
}
gboolean
log_macro_expand(GString *result, gint id, guint32 flags, gint ts_format, TimeZoneInfo *zone_info, gint frac_digits, gint32 seq_num, LogMessage *msg)
{
switch (id)
{
case M_FACILITY:
{
/* facility */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_FACMASK, sl_facilities);
if (n)
{
g_string_append(result, n);
}
else
{
g_string_sprintfa(result, "%x", (msg->pri & LOG_FACMASK) >> 3);
}
break;
}
case M_FACILITY_NUM:
{
g_string_sprintfa(result, "%d", (msg->pri & LOG_FACMASK) >> 3);
break;
}
case M_LEVEL:
{
/* level */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_PRIMASK, sl_levels);
if (n)
{
g_string_append(result, n);
}
else
{
g_string_sprintfa(result, "%d", msg->pri & LOG_PRIMASK);
}
break;
}
case M_LEVEL_NUM:
{
g_string_sprintfa(result, "%d", (msg->pri & LOG_PRIMASK));
break;
}
case M_TAG:
{
g_string_sprintfa(result, "%02x", msg->pri);
break;
}
case M_TAGS:
{
log_msg_print_tags(msg, result);
break;
}
case M_BSDTAG:
{
g_string_sprintfa(result, "%1d%c", (msg->pri & LOG_PRIMASK), (((msg->pri & LOG_FACMASK) >> 3) + 'A'));
break;
}
case M_PRI:
{
g_string_sprintfa(result, "%d", msg->pri);
break;
}
case M_HOST:
{
if (msg->flags & LF_CHAINED_HOSTNAME)
{
/* host */
const gchar *p1, *p2;
int remaining, length;
gssize host_len;
const gchar *host = log_msg_get_value(msg, LM_V_HOST, &host_len);
p1 = memchr(host, '@', host_len);
if (p1)
p1++;
else
p1 = host;
remaining = host_len - (p1 - host);
p2 = memchr(p1, '/', remaining);
length = p2 ? p2 - p1
: host_len - (p1 - host);
result_append(result, p1, length, !!(flags & LT_ESCAPE));
}
else
{
result_append_value(result, msg, LM_V_HOST, !!(flags & LT_ESCAPE));
}
break;
}
case M_SDATA:
if (flags & LT_ESCAPE)
{
GString *sdstr = g_string_sized_new(0);
log_msg_append_format_sdata(msg, sdstr);
result_append(result, sdstr->str, sdstr->len, TRUE);
g_string_free(sdstr, TRUE);
}
else
{
log_msg_append_format_sdata(msg, result);
}
break;
case M_MSGHDR:
if ((msg->flags & LF_LEGACY_MSGHDR))
{
/* fast path for now, as most messages come from legacy devices */
result_append_value(result, msg, LM_V_LEGACY_MSGHDR, !!(flags & LT_ESCAPE));
}
else
{
/* message, complete with program name and pid */
gssize len;
len = result->len;
result_append_value(result, msg, LM_V_PROGRAM, !!(flags & LT_ESCAPE));
if (len != result->len)
{
const gchar *pid = log_msg_get_value(msg, LM_V_PID, &len);
if (len > 0)
{
result_append(result, "[", 1, FALSE);
result_append(result, pid, len, !!(flags & LT_ESCAPE));
result_append(result, "]", 1, FALSE);
}
result_append(result, ": ", 2, FALSE);
}
}
break;
case M_MESSAGE:
if (!cfg_check_current_config_version(0x0300))
log_macro_expand(result, M_MSGHDR, flags, ts_format, zone_info, frac_digits, seq_num, msg);
result_append_value(result, msg, LM_V_MESSAGE, !!(flags & LT_ESCAPE));
break;
case M_SOURCE_IP:
{
gchar *ip;
if (msg->saddr && (g_sockaddr_inet_check(msg->saddr) ||
#if ENABLE_IPV6
g_sockaddr_inet6_check(msg->saddr))
#else
0)
#endif
)
{
gchar buf[MAX_SOCKADDR_STRING];
g_sockaddr_format(msg->saddr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
ip = buf;
}
else
{
ip = "127.0.0.1";
}
result_append(result, ip, strlen(ip), !!(flags & LT_ESCAPE));
break;
}
case M_SEQNUM:
{
if (seq_num)
g_string_sprintfa(result, "%d", seq_num);
break;
}
default:
{
/* year, month, day */
struct tm *tm, tm_storage;
gchar buf[64];
gint length;
time_t t;
LogStamp *stamp;
glong zone_ofs;
if (id >= M_TIME_FIRST && id <= M_TIME_LAST)
{
if (flags & LT_STAMP_RECVD)
stamp = &msg->timestamps[LM_TS_RECVD];
else
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_RECVD_OFS && id <= M_TIME_LAST + M_RECVD_OFS)
{
id -= M_RECVD_OFS;
stamp = &msg->timestamps[LM_TS_RECVD];
}
else if (id >= M_TIME_FIRST + M_STAMP_OFS && id <= M_TIME_LAST + M_STAMP_OFS)
{
id -= M_STAMP_OFS;
stamp = &msg->timestamps[LM_TS_STAMP];
}
else
{
g_assert_not_reached();
break;
}
/* try to use the following zone values in order:
* destination specific timezone, if one is specified
* message specific timezone, if one is specified
* local timezone
*/
zone_ofs = (zone_info != NULL ? time_zone_info_get_offset(zone_info, stamp->time.tv_sec) : stamp->zone_offset);
if (zone_ofs == -1)
zone_ofs = stamp->zone_offset;
t = stamp->time.tv_sec + zone_ofs;
tm = gmtime_r(&t, &tm_storage);
switch (id)
{
case M_WEEK_DAY_ABBREV:
g_string_append_len(result, weekday_names_abbrev[tm->tm_wday], 3);
break;
case M_WEEK_DAY_NAME:
g_string_append(result, weekday_names[tm->tm_wday]);
break;
case M_WEEK_DAY:
g_string_sprintfa(result, "%d", tm->tm_wday + 1);
break;
case M_WEEK:
g_string_sprintfa(result, "%02d", (tm->tm_yday - (tm->tm_wday - 1 + 7) % 7 + 7) / 7);
break;
case M_YEAR:
g_string_sprintfa(result, "%04d", tm->tm_year + 1900);
break;
case M_YEAR_DAY:
g_string_sprintfa(result, "%03d", tm->tm_yday + 1);
break;
case M_MONTH:
g_string_sprintfa(result, "%02d", tm->tm_mon + 1);
break;
case M_MONTH_WEEK:
g_string_sprintfa(result, "%d", ((tm->tm_mday / 7) + ((tm->tm_wday > 0) && ((tm->tm_mday % 7) >= tm->tm_wday))));
break;
case M_MONTH_ABBREV:
g_string_append_len(result, month_names_abbrev[tm->tm_mon], 3);
break;
case M_MONTH_NAME:
g_string_append(result, month_names[tm->tm_mon]);
break;
case M_DAY:
g_string_sprintfa(result, "%02d", tm->tm_mday);
break;
case M_HOUR:
g_string_sprintfa(result, "%02d", tm->tm_hour);
break;
case M_MIN:
g_string_sprintfa(result, "%02d", tm->tm_min);
break;
case M_SEC:
g_string_sprintfa(result, "%02d", tm->tm_sec);
break;
case M_DATE:
case M_STAMP:
case M_ISODATE:
case M_FULLDATE:
case M_UNIXTIME:
{
GString *s = g_string_sized_new(0);
gint format = id == M_DATE ? TS_FMT_BSD :
id == M_ISODATE ? TS_FMT_ISO :
id == M_FULLDATE ? TS_FMT_FULL :
id == M_UNIXTIME ? TS_FMT_UNIX :
ts_format;
log_stamp_format(stamp, s, format, zone_ofs, frac_digits);
g_string_append_len(result, s->str, s->len);
g_string_free(s, TRUE);
break;
}
case M_TZ:
case M_TZOFFSET:
length = format_zone_info(buf, sizeof(buf), zone_ofs);
g_string_append_len(result, buf, length);
break;
}
break;
}
}
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;
}
gboolean
log_macro_expand(GString *result, gint id, gboolean escape, LogTemplateOptions *opts, gint tz, gint32 seq_num, const gchar *context_id, LogMessage *msg)
{
static LogTemplateOptions default_opts = { TRUE, TS_FMT_BSD, 0, { NULL, NULL }, { NULL, NULL } };
if (!opts)
opts = &default_opts;
switch (id)
{
case M_FACILITY:
{
/* facility */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_FACMASK, sl_facilities);
if (n)
{
g_string_append(result, n);
}
else
{
format_uint32_padded(result, 0, 0, 16, (msg->pri & LOG_FACMASK) >> 3);
}
break;
}
case M_FACILITY_NUM:
{
format_uint32_padded(result, 0, 0, 10, (msg->pri & LOG_FACMASK) >> 3);
break;
}
case M_LEVEL:
{
/* level */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_PRIMASK, sl_levels);
if (n)
{
g_string_append(result, n);
}
else
{
format_uint32_padded(result, 0, 0, 10, msg->pri & LOG_PRIMASK);
}
break;
}
case M_LEVEL_NUM:
{
format_uint32_padded(result, 0, 0, 10, msg->pri & LOG_PRIMASK);
break;
}
case M_TAG:
{
format_uint32_padded(result, 2, '0', 16, msg->pri);
break;
}
case M_TAGS:
{
log_msg_print_tags(msg, result);
break;
}
case M_BSDTAG:
{
format_uint32_padded(result, 0, 0, 10, (msg->pri & LOG_PRIMASK));
g_string_append_c(result, (((msg->pri & LOG_FACMASK) >> 3) + 'A'));
break;
}
case M_PRI:
{
format_uint32_padded(result, 0, 0, 10, msg->pri);
break;
}
case M_HOST:
{
if (msg->flags & LF_CHAINED_HOSTNAME)
{
/* host */
const gchar *p1, *p2;
int remaining, length;
gssize host_len;
const gchar *host = log_msg_get_value(msg, LM_V_HOST, &host_len);
p1 = memchr(host, '@', host_len);
if (p1)
p1++;
else
p1 = host;
remaining = host_len - (p1 - host);
p2 = memchr(p1, '/', remaining);
length = p2 ? p2 - p1
: host_len - (p1 - host);
result_append(result, p1, length, escape);
}
else
{
result_append_value(result, msg, LM_V_HOST, escape);
}
break;
}
case M_SDATA:
if (escape)
{
GString *sdstr = g_string_sized_new(0);
log_msg_append_format_sdata(msg, sdstr, seq_num);
result_append(result, sdstr->str, sdstr->len, TRUE);
g_string_free(sdstr, TRUE);
}
else
{
log_msg_append_format_sdata(msg, result, seq_num);
}
break;
case M_MSGHDR:
if ((msg->flags & LF_LEGACY_MSGHDR))
{
/* fast path for now, as most messages come from legacy devices */
result_append_value(result, msg, LM_V_LEGACY_MSGHDR, escape);
}
else
{
/* message, complete with program name and pid */
gssize len;
len = result->len;
result_append_value(result, msg, LM_V_PROGRAM, escape);
if (len != result->len)
{
const gchar *pid = log_msg_get_value(msg, LM_V_PID, &len);
if (len > 0)
{
result_append(result, "[", 1, FALSE);
result_append(result, pid, len, escape);
result_append(result, "]", 1, FALSE);
}
result_append(result, ": ", 2, FALSE);
}
}
break;
case M_MESSAGE:
if (cfg_is_config_version_older(configuration, 0x0300))
log_macro_expand(result, M_MSGHDR, escape, opts, tz, seq_num, context_id, msg);
result_append_value(result, msg, LM_V_MESSAGE, escape);
break;
case M_SOURCE_IP:
{
gchar *ip;
if (msg->saddr && (g_sockaddr_inet_check(msg->saddr) ||
#if ENABLE_IPV6
g_sockaddr_inet6_check(msg->saddr))
#else
0)
#endif
)
{
gchar buf[MAX_SOCKADDR_STRING];
g_sockaddr_format(msg->saddr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
ip = buf;
}
else
{
ip = "127.0.0.1";
}
result_append(result, ip, strlen(ip), escape);
break;
}
case M_SEQNUM:
{
if (seq_num)
{
format_uint32_padded(result, 0, 0, 10, seq_num);
}
break;
}
case M_CONTEXT_ID:
{
if (context_id)
{
result_append(result, context_id, strlen(context_id), escape);
}
break;
}
case M_LOGHOST:
{
gsize hname_len;
const gchar *hname = get_local_hostname(&hname_len);
result_append(result, hname, hname_len, escape);
break;
}
case M_SYSUPTIME:
{
GTimeVal ct;
g_get_current_time(&ct);
format_uint64_padded(result, 0, 0, 10, g_time_val_diff(&ct, &app_uptime) / 1000 / 10);
break;
}
default:
{
/* year, month, day */
struct tm *tm, tm_storage;
gchar buf[64];
gint length;
time_t t;
LogStamp *stamp, sstamp;
glong zone_ofs;
guint tmp_hour;
if (id >= M_TIME_FIRST && id <= M_TIME_LAST)
{
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_RECVD_OFS && id <= M_TIME_LAST + M_RECVD_OFS)
{
id -= M_RECVD_OFS;
stamp = &msg->timestamps[LM_TS_RECVD];
}
else if (id >= M_TIME_FIRST + M_STAMP_OFS && id <= M_TIME_LAST + M_STAMP_OFS)
{
id -= M_STAMP_OFS;
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_CSTAMP_OFS && id <= M_TIME_LAST + M_CSTAMP_OFS)
{
GTimeVal tv;
id -= M_CSTAMP_OFS;
cached_g_current_time(&tv);
sstamp.tv_sec = tv.tv_sec;
sstamp.tv_usec = tv.tv_usec;
sstamp.zone_offset = -1;
stamp = &sstamp;
}
else
{
g_assert_not_reached();
break;
}
/* try to use the following zone values in order:
* destination specific timezone, if one is specified
* message specific timezone, if one is specified
* local timezone
*/
zone_ofs = (opts->time_zone_info[tz] != NULL ? time_zone_info_get_offset(opts->time_zone_info[tz], stamp->tv_sec) : stamp->zone_offset);
if (zone_ofs == -1)
zone_ofs = stamp->zone_offset;
t = stamp->tv_sec + zone_ofs;
cached_gmtime(&t, &tm_storage);
tm = &tm_storage;
switch (id)
{
case M_WEEK_DAY_ABBREV:
g_string_append_len(result, weekday_names_abbrev[tm->tm_wday], 3);
break;
case M_WEEK_DAY_NAME:
g_string_append(result, weekday_names[tm->tm_wday]);
break;
case M_WEEK_DAY:
format_uint32_padded(result, 0, 0, 10, tm->tm_wday + 1);
break;
case M_WEEK:
format_uint32_padded(result, 2, '0', 10, (tm->tm_yday - (tm->tm_wday - 1 + 7) % 7 + 7) / 7);
break;
case M_YEAR:
format_uint32_padded(result, 4, '0', 10, tm->tm_year + 1900);
break;
case M_YEAR_DAY:
format_uint32_padded(result, 3, '0', 10, tm->tm_yday + 1);
break;
case M_MONTH:
format_uint32_padded(result, 2, '0', 10, tm->tm_mon + 1);
break;
case M_MONTH_WEEK:
format_uint32_padded(result, 0, 0, 10, ((tm->tm_mday / 7) + ((tm->tm_wday > 0) && ((tm->tm_mday % 7) >= tm->tm_wday))));
break;
case M_MONTH_ABBREV:
g_string_append_len(result, month_names_abbrev[tm->tm_mon], 3);
break;
case M_MONTH_NAME:
g_string_append(result, month_names[tm->tm_mon]);
break;
case M_DAY:
format_uint32_padded(result, 2, '0', 10, tm->tm_mday);
break;
case M_HOUR:
format_uint32_padded(result, 2, '0', 10, tm->tm_hour);
break;
case M_HOUR12:
if (tm->tm_hour < 12)
tmp_hour = tm->tm_hour;
else
tmp_hour = tm->tm_hour - 12;
if (tmp_hour == 0)
tmp_hour = 12;
format_uint32_padded(result, 2, '0', 10, tmp_hour);
break;
case M_MIN:
format_uint32_padded(result, 2, '0', 10, tm->tm_min);
break;
case M_SEC:
format_uint32_padded(result, 2, '0', 10, tm->tm_sec);
break;
case M_MSEC:
format_uint32_padded(result, 3, '0', 10, stamp->tv_usec/1000);
break;
case M_USEC:
format_uint32_padded(result, 6, '0', 10, stamp->tv_usec);
break;
case M_AMPM:
g_string_append(result, tm->tm_hour < 12 ? "AM" : "PM");
break;
case M_DATE:
case M_STAMP:
case M_ISODATE:
case M_FULLDATE:
case M_UNIXTIME:
{
gint format = id == M_DATE ? TS_FMT_BSD :
id == M_ISODATE ? TS_FMT_ISO :
id == M_FULLDATE ? TS_FMT_FULL :
id == M_UNIXTIME ? TS_FMT_UNIX :
opts->ts_format;
log_stamp_append_format(stamp, result, format, zone_ofs, opts->frac_digits);
break;
}
case M_TZ:
case M_TZOFFSET:
length = format_zone_info(buf, sizeof(buf), zone_ofs);
g_string_append_len(result, buf, length);
break;
}
break;
}
}
static gboolean
afsocket_dd_connected(AFSocketDestDriver *self)
{
gchar buf1[256], buf2[256];
int error = 0;
socklen_t errorlen = sizeof(error);
LogTransport *transport;
LogProto *proto;
guint32 transport_flags = 0;
main_loop_assert_main_thread();
if (iv_fd_registered(&self->connect_fd))
iv_fd_unregister(&self->connect_fd);
if (self->flags & AFSOCKET_STREAM)
{
transport_flags |= LTF_SHUTDOWN;
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);
#if ENABLE_SSL
if (self->tls_context)
{
TLSSession *tls_session;
tls_session = tls_context_setup_session(self->tls_context);
if (!tls_session)
{
goto error_reconnect;
}
tls_session_set_verify(tls_session, afsocket_dd_tls_verify_callback, self, NULL);
transport = log_transport_tls_new(tls_session, self->fd, transport_flags);
}
else
#endif
transport = log_transport_plain_new(self->fd, transport_flags);
if (self->flags & AFSOCKET_SYSLOG_PROTOCOL)
{
if (self->flags & AFSOCKET_STREAM)
proto = log_proto_framed_client_new(transport);
else
proto = log_proto_text_client_new(transport);
}
else
{
proto = log_proto_text_client_new(transport);
}
log_writer_reopen(self->writer, proto);
return TRUE;
error_reconnect:
close(self->fd);
self->fd = -1;
afsocket_dd_start_reconnect_timer(self);
return FALSE;
}
