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