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; }