Journald *
journald_mock_new()
{
Journald *self = g_new0(Journald, 1);
pipe(self->fds);
g_fd_set_nonblock(self->fds[0], TRUE);
g_fd_set_nonblock(self->fds[1], TRUE);
return self;
}
static gboolean
afprogram_dd_reopen(AFProgramDestDriver *self)
{
int fd;
if (self->pid != -1)
{
msg_verbose("Sending destination program a TERM signal",
evt_tag_str("cmdline", self->cmdline->str),
evt_tag_int("child_pid", self->pid),
NULL);
kill(self->pid, SIGTERM);
self->pid = -1;
}
msg_verbose("Starting destination program",
evt_tag_str("cmdline", self->cmdline->str),
NULL);
if (!afprogram_popen(self->cmdline->str, G_IO_OUT, &self->pid, &fd))
return FALSE;
child_manager_register(self->pid, afprogram_dd_exit, log_pipe_ref(&self->super.super.super), (GDestroyNotify) log_pipe_unref);
g_fd_set_nonblock(fd, TRUE);
log_writer_reopen(self->writer, log_proto_text_client_new(log_transport_plain_new(fd, 0)));
return TRUE;
}
static gboolean
systemd_syslog_sd_acquire_socket(AFSocketSourceDriver *s,
gint *acquired_fd)
{
gint fd, number_of_fds;
*acquired_fd = -1;
fd = -1;
number_of_fds = sd_listen_fds(0);
if (number_of_fds > 1)
{
msg_error("Systemd socket activation failed: got more than one fd",
evt_tag_int("number", number_of_fds),
NULL);
return TRUE;
}
else if (number_of_fds < 1)
{
msg_error("Failed to acquire /run/systemd/journal/syslog socket, disabling systemd-syslog source",
NULL);
return TRUE;
}
else
{
fd = SD_LISTEN_FDS_START;
msg_debug("Systemd socket activation",
evt_tag_int("file-descriptor", fd),
NULL);
if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, NULL, 0))
{
*acquired_fd = fd;
}
else
{
msg_error("The systemd supplied UNIX domain socket is of a"
" different type, check the configured driver and"
" the matching systemd unit file",
evt_tag_int("systemd-sock-fd", fd),
evt_tag_str("expecting", "unix-dgram()"),
NULL);
*acquired_fd = -1;
return TRUE;
}
}
if (*acquired_fd != -1)
{
g_fd_set_nonblock(*acquired_fd, TRUE);
msg_verbose("Acquired systemd syslog socket",
evt_tag_int("systemd-syslog-sock-fd", *acquired_fd),
NULL);
return TRUE;
}
return TRUE;
}
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
afprogram_sd_init(LogPipe *s)
{
AFProgramSourceDriver *self = (AFProgramSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
if (!log_src_driver_init_method(s))
return FALSE;
if (cfg)
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
msg_verbose("Starting source program",
evt_tag_str("cmdline", self->process_info.cmdline->str));
if (!afprogram_popen(&self->process_info, G_IO_IN, &fd))
return FALSE;
/* parent */
child_manager_register(self->process_info.pid, afprogram_sd_exit, log_pipe_ref(&self->super.super.super),
(GDestroyNotify) log_pipe_unref);
g_fd_set_nonblock(fd, TRUE);
g_fd_set_cloexec(fd, TRUE);
if (!self->reader)
{
LogTransport *transport;
transport = log_transport_pipe_new(fd);
self->reader = log_reader_new(s->cfg);
log_reader_reopen(self->reader, log_proto_text_server_new(transport, &self->reader_options.proto_options.super),
poll_fd_events_new(fd));
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->process_info.cmdline->str);
}
log_pipe_append((LogPipe *) self->reader, &self->super.super.super);
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing program source, closing fd",
evt_tag_int("fd", fd));
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
return TRUE;
}
gboolean
transport_mapper_open_socket(TransportMapper *self,
SocketOptions *socket_options,
GSockAddr *bind_addr,
AFSocketDirection dir,
int *fd)
{
gint sock;
sock = socket(self->address_family, self->sock_type, self->sock_proto);
if (sock < 0)
{
msg_error("Error creating socket",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
goto error;
}
g_fd_set_nonblock(sock, TRUE);
g_fd_set_cloexec(sock, TRUE);
if (!transport_mapper_privileged_bind(sock, bind_addr))
{
gchar buf[256];
msg_error("Error binding socket",
evt_tag_str("addr", g_sockaddr_format(bind_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
goto error_close;
}
if (!socket_options_setup_socket(socket_options, sock, bind_addr, dir))
goto error_close;
*fd = sock;
return TRUE;
error_close:
close(sock);
error:
*fd = -1;
return FALSE;
}
static gboolean
afsocket_open_socket(GSockAddr *bind_addr, int stream_or_dgram, int *fd)
{
gint sock;
if (stream_or_dgram)
sock = socket(bind_addr->sa.sa_family, SOCK_STREAM, 0);
else
sock = socket(bind_addr->sa.sa_family, SOCK_DGRAM, 0);
if (sock != -1)
{
cap_t saved_caps;
g_fd_set_nonblock(sock, TRUE);
g_fd_set_cloexec(sock, TRUE);
saved_caps = g_process_cap_save();
g_process_cap_modify(CAP_NET_BIND_SERVICE, TRUE);
g_process_cap_modify(CAP_DAC_OVERRIDE, TRUE);
if (g_bind(sock, bind_addr) != G_IO_STATUS_NORMAL)
{
gchar buf[256];
g_process_cap_restore(saved_caps);
msg_error("Error binding socket",
evt_tag_str("addr", g_sockaddr_format(bind_addr, buf, sizeof(buf), GSA_FULL)),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(sock);
return FALSE;
}
g_process_cap_restore(saved_caps);
*fd = sock;
return TRUE;
}
else
{
msg_error("Error creating socket",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return FALSE;
}
}
static gboolean
afprogram_dd_reopen(AFProgramDestDriver *self)
{
int fd;
afprogram_dd_kill_child(self);
msg_verbose("Starting destination program",
evt_tag_str("cmdline", self->cmdline->str),
NULL);
if (!afprogram_popen(self->cmdline->str, G_IO_OUT, &self->pid, &fd))
return FALSE;
child_manager_register(self->pid, afprogram_dd_exit, log_pipe_ref(&self->super.super.super), (GDestroyNotify) log_pipe_unref);
g_fd_set_nonblock(fd, TRUE);
log_writer_reopen(self->writer, log_proto_text_client_new(log_transport_pipe_new(fd), &self->writer_options.proto_options.super));
return TRUE;
}
static inline gboolean
afprogram_dd_open_program(AFProgramDestDriver *self, int *fd)
{
if (self->process_info.pid == -1)
{
msg_verbose("Starting destination program",
evt_tag_str("cmdline", self->process_info.cmdline->str));
if (!afprogram_popen(&self->process_info, G_IO_OUT, fd))
return FALSE;
g_fd_set_nonblock(*fd, TRUE);
}
child_manager_register(self->process_info.pid, afprogram_dd_exit, log_pipe_ref(&self->super.super.super),
(GDestroyNotify)log_pipe_unref);
return TRUE;
}
static gboolean
afstreams_sd_init(LogPipe *s)
{
AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
if (!log_src_driver_init_method(s))
return FALSE;
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
fd = open(self->dev_filename->str, O_RDONLY | O_NOCTTY | O_NONBLOCK);
if (fd != -1)
{
struct strioctl ioc;
g_fd_set_cloexec(fd, TRUE);
memset(&ioc, 0, sizeof(ioc));
ioc.ic_cmd = I_CONSLOG;
if (ioctl(fd, I_STR, &ioc) < 0)
{
msg_error("Error in ioctl(I_STR, I_CONSLOG)",
evt_tag_str(EVT_TAG_FILENAME, self->dev_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno));
close(fd);
return FALSE;
}
g_fd_set_nonblock(fd, TRUE);
self->reader = log_reader_new(cfg);
log_reader_reopen(self->reader, log_proto_dgram_server_new(log_transport_streams_new(fd), &self->reader_options.proto_options.super), poll_fd_events_new(fd));
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL1,
SCS_SUN_STREAMS,
self->super.super.id,
self->dev_filename->str);
log_pipe_append((LogPipe *) self->reader, s);
if (self->door_filename)
{
/* door creation is deferred, because it creates threads which is
* not inherited through forks, and syslog-ng forks during
* startup, but _after_ the configuration was initialized */
register_application_hook(AH_POST_DAEMONIZED, afstreams_init_door, self);
}
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd));
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
}
else
{
msg_error("Error opening syslog device",
evt_tag_str(EVT_TAG_FILENAME, self->dev_filename->str),
evt_tag_errno(EVT_TAG_OSERROR, errno));
return FALSE;
}
return TRUE;
}
static gboolean
afprogram_dd_init(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
int msg_pipe[2];
if (cfg)
log_writer_options_init(&self->writer_options, cfg, 0, afprogram_dd_format_stats_name(self));
msg_verbose("Starting destination program",
evt_tag_str("cmdline", self->cmdline->str),
NULL);
if (pipe(msg_pipe) == -1)
{
msg_error("Error creating program pipe",
evt_tag_str("cmdline", self->cmdline->str),
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
return FALSE;
}
if ((self->pid = fork()) < 0)
{
msg_error("Error in fork()",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(msg_pipe[0]);
close(msg_pipe[1]);
return FALSE;
}
if (self->pid == 0)
{
/* child */
int devnull = open("/dev/null", O_WRONLY);
if (devnull == -1)
{
_exit(127);
}
dup2(msg_pipe[0], 0);
dup2(devnull, 1);
dup2(devnull, 2);
close(devnull);
close(msg_pipe[0]);
close(msg_pipe[1]);
execl("/bin/sh", "/bin/sh", "-c", self->cmdline->str, NULL);
_exit(127);
}
else
{
/* parent */
child_manager_register(self->pid, afprogram_dd_exit, log_pipe_ref(&self->super.super), (GDestroyNotify) log_pipe_unref);
close(msg_pipe[0]);
g_fd_set_nonblock(msg_pipe[1], TRUE);
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_FILE, s, &self->writer_options);
#if 0/*start dongshu*/
log_writer_reopen(self->writer, fd_write_new(msg_pipe[1]));
#else
log_writer_reopen(self->writer, fd_write_new(msg_pipe[1],NULL));
#endif/*end*/
log_pipe_init(self->writer, NULL, NULL);
log_pipe_append(&self->super.super, self->writer);
}
return TRUE;
}
static gboolean
afunix_sd_acquire_named_socket(AFSocketSourceDriver *s, gint *result_fd,
const gchar *filename)
{
AFUnixSourceDriver *self = (AFUnixSourceDriver *) s;
gint fd, fds;
*result_fd = -1;
fd = -1;
fds = sd_listen_fds(0);
if (fds == 0)
return TRUE;
msg_debug("Systemd socket activation",
evt_tag_int("systemd-sockets", fds),
evt_tag_str("systemd-listen-pid", getenv("LISTEN_PID")),
evt_tag_str("systemd-listen-fds", getenv("LISTEN_FDS")),
NULL);
if (fds < 0)
{
msg_error("Failed to acquire systemd sockets, incorrectly set LISTEN_FDS environment variable?",
NULL);
return FALSE;
}
else if (fds > 0)
{
for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + fds; fd++)
{
/* check if any type is available */
if (sd_is_socket_unix(fd, 0, -1, filename, 0))
{
/* check if it matches our idea of the socket type */
if (sd_is_socket_unix(fd, self->super.transport_mapper->sock_type, -1, filename, 0))
{
*result_fd = fd;
break;
}
else
{
msg_error("The systemd supplied UNIX domain socket is of a different type, check the configured driver and the matching systemd unit file",
evt_tag_str("filename", filename),
evt_tag_int("systemd-sock-fd", fd),
evt_tag_str("expecting", self->super.transport_mapper->sock_type == SOCK_STREAM ? "unix-stream()" : "unix-dgram()"),
NULL);
return FALSE;
}
}
else
{
/* systemd passed an fd we didn't really care about. This is
* not an error, but might be worth mentioning it at the debug
* level.
*/
msg_debug("Ignoring systemd supplied fd as it is not a UNIX domain socket",
evt_tag_str("filename", filename),
evt_tag_int("systemd-sock-fd", fd),
NULL);
}
}
}
if (*result_fd != -1)
{
g_fd_set_nonblock(*result_fd, TRUE);
g_fd_set_cloexec(*result_fd, TRUE);
msg_verbose("Acquired systemd socket",
evt_tag_str("filename", filename),
evt_tag_int("systemd-sock-fd", *result_fd),
NULL);
return TRUE;
}
return TRUE;
}
