static gboolean afsocket_sd_setup_reader_options(AFSocketSourceDriver *self) { GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super); if (self->transport_mapper->sock_type == SOCK_STREAM && !self->window_size_initialized) { /* distribute the window evenly between each of our possible * connections. This is quite pessimistic and can result in very low * window sizes. Increase that but warn the user at the same time */ self->reader_options.super.init_window_size /= self->max_connections; if (self->reader_options.super.init_window_size < 100) { msg_warning("WARNING: window sizing for tcp sources were changed in " VERSION_3_3 ", the configuration value was divided by the value of max-connections(). The result was too small, clamping to 100 entries. Ensure you have a proper log_fifo_size setting to avoid message loss.", evt_tag_int("orig_log_iw_size", self->reader_options.super.init_window_size), evt_tag_int("new_log_iw_size", 100), evt_tag_int("min_log_fifo_size", 100 * self->max_connections), NULL); self->reader_options.super.init_window_size = 100; } self->window_size_initialized = TRUE; } log_reader_options_init(&self->reader_options, cfg, self->super.super.group); return TRUE; }
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; }
static gboolean affile_sd_init(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist) { AFFileSourceDriver *self = (AFFileSourceDriver *) s; int fd, flags; if (self->flags & AFFILE_PIPE) flags = O_RDWR | O_NOCTTY | O_NONBLOCK | O_LARGEFILE; else flags = O_RDONLY | O_NOCTTY | O_NONBLOCK | O_LARGEFILE; log_reader_options_init(&self->reader_options, cfg); #if 0/*start dongshu*/ if (affile_open_file(self->filename->str, flags, -1, -1, -1, 0, 0, 0, 0, &fd)) #else if (affile_open_file(self->filename->str, flags, -1, -1, -1, 0, 0, 0, 0, &fd,0)) #endif/*end*/ { self->reader = log_reader_new(fd_read_new(fd, 0), LR_LOCAL | LR_NOMREAD, s, &self->reader_options); log_pipe_append(self->reader, s); /* call log_reader_init() */ if (!log_pipe_init(self->reader, NULL, NULL)) { msg_error("Error initializing log_reader, closing fd", evt_tag_int("fd", fd), NULL); log_pipe_unref(self->reader); self->reader = NULL; close(fd); return FALSE; } } else { msg_error("Error opening file for reading", evt_tag_str("filename", self->filename->str), evt_tag_errno(EVT_TAG_OSERROR, errno), NULL); return self->super.optional; } 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 affile_sd_init(LogPipe *s) { AFFileSourceDriver *self = (AFFileSourceDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); gint fd; gboolean file_opened, open_deferred = FALSE; if (!log_src_driver_init_method(s)) return FALSE; log_reader_options_init(&self->reader_options, cfg, self->super.super.group); if ((self->multi_line_mode != MLM_PREFIX_GARBAGE && self->multi_line_mode != MLM_PREFIX_SUFFIX ) && (self->multi_line_prefix || self->multi_line_garbage)) { msg_error("multi-line-prefix() and/or multi-line-garbage() specified but multi-line-mode() is not regexp based (prefix-garbage or prefix-suffix), please set multi-line-mode() properly", NULL); return FALSE; } file_opened = affile_sd_open_file(self, self->filename->str, &fd); if (!file_opened && self->follow_freq > 0) { msg_info("Follow-mode file source not found, deferring open", evt_tag_str("filename", self->filename->str), NULL); open_deferred = TRUE; fd = -1; } if (file_opened || open_deferred) { LogProtoServer *proto; PollEvents *poll_events; poll_events = affile_sd_construct_poll_events(self, fd); if (!poll_events) { close(fd); return FALSE; } proto = affile_sd_construct_proto(self, fd); self->reader = log_reader_new(self->super.super.super.cfg); log_reader_reopen(self->reader, proto, poll_events); log_reader_set_options(self->reader, s, &self->reader_options, STATS_LEVEL1, SCS_FILE, self->super.super.id, self->filename->str); /* NOTE: if the file could not be opened, we ignore the last * remembered file position, if the file is created in the future * we're going to read from the start. */ log_pipe_append((LogPipe *) self->reader, s); if (!log_pipe_init((LogPipe *) self->reader)) { msg_error("Error initializing log_reader, closing fd", evt_tag_int("fd", fd), NULL); log_pipe_unref((LogPipe *) self->reader); self->reader = NULL; close(fd); return FALSE; } affile_sd_recover_state(s, cfg, proto); } else { msg_error("Error opening file for reading", evt_tag_str("filename", self->filename->str), evt_tag_errno(EVT_TAG_OSERROR, errno), NULL); return self->super.super.optional; } return TRUE; }
static gboolean affile_sd_init(LogPipe *s) { AFFileSourceDriver *self = (AFFileSourceDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); gint fd; gboolean file_opened, open_deferred = FALSE; log_reader_options_init(&self->reader_options, cfg, self->super.group); file_opened = affile_sd_open_file(self, self->filename->str, &fd); if (!file_opened && self->reader_options.follow_freq > 0) { msg_info("Follow-mode file source not found, deferring open", evt_tag_str("filename", self->filename->str), NULL); open_deferred = TRUE; fd = -1; } if (file_opened || open_deferred) { LogTransport *transport; transport = log_transport_plain_new(fd, self->filename, NULL, 0); transport->timeout = 10; /* FIXME: we shouldn't use reader_options to store log protocol parameters */ self->reader = log_reader_new( log_proto_plain_new_server(transport, self->reader_options.padding, self->reader_options.msg_size, ((self->reader_options.follow_freq > 0) ? LPPF_IGNORE_EOF : LPPF_NOMREAD) ), LR_LOCAL); log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_FILE, self->super.id, self->filename->str); log_reader_set_follow_filename(self->reader, self->filename->str); /* NOTE: if the file could not be opened, we ignore the last * remembered file position, if the file is created in the future * we're going to read from the start. */ affile_sd_load_pos(s, cfg); log_pipe_append(self->reader, s); if (!log_pipe_init(self->reader, NULL)) { msg_error("Error initializing log_reader, closing fd", evt_tag_int("fd", fd), NULL); log_pipe_unref(self->reader); self->reader = NULL; close(fd); return FALSE; } } else { msg_error("Error opening file for reading", evt_tag_str("filename", self->filename->str), evt_tag_errno(EVT_TAG_OSERROR, errno), NULL); return self->super.optional; } return TRUE; }
gboolean afsocket_sd_init(LogPipe *s) { AFSocketSourceDriver *self = (AFSocketSourceDriver *) s; gint sock; gboolean res = FALSE; GlobalConfig *cfg = log_pipe_get_config(s); if (!log_src_driver_init_method(s)) return FALSE; if (!afsocket_sd_apply_transport(self)) return FALSE; g_assert(self->transport); g_assert(self->bind_addr); if ((self->flags & (AFSOCKET_STREAM + AFSOCKET_WNDSIZE_INITED)) == AFSOCKET_STREAM) { /* distribute the window evenly between each of our possible * connections. This is quite pessimistic and can result in very low * window sizes. Increase that but warn the user at the same time */ self->reader_options.super.init_window_size /= self->max_connections; if (self->reader_options.super.init_window_size < 100) { msg_warning("WARNING: window sizing for tcp sources were changed in syslog-ng 3.3, the configuration value was divided by the value of max-connections(). The result was too small, clamping to 100 entries. Ensure you have a proper log_fifo_size setting to avoid message loss.", evt_tag_int("orig_log_iw_size", self->reader_options.super.init_window_size), evt_tag_int("new_log_iw_size", 100), evt_tag_int("min_log_fifo_size", 100 * self->max_connections), NULL); self->reader_options.super.init_window_size = 100; } self->flags |= AFSOCKET_WNDSIZE_INITED; } log_reader_options_init(&self->reader_options, cfg, self->super.super.group); /* fetch persistent connections first */ if ((self->flags & AFSOCKET_KEEP_ALIVE)) { GList *p; self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE)); for (p = self->connections; p; p = p->next) { afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self); log_pipe_init((LogPipe *) p->data, NULL); } } /* ok, we have connection list, check if we need to open a listener */ sock = -1; if (self->flags & AFSOCKET_STREAM) { if (self->flags & AFSOCKET_KEEP_ALIVE) { /* NOTE: this assumes that fd 0 will never be used for listening fds, * main.c opens fd 0 so this assumption can hold */ sock = GPOINTER_TO_UINT(cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, TRUE))) - 1; } if (sock == -1) { if (!afsocket_sd_acquire_socket(self, &sock)) return self->super.super.optional; if (sock == -1 && !afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock)) return self->super.super.optional; } /* set up listening source */ if (listen(sock, self->listen_backlog) < 0) { msg_error("Error during listen()", evt_tag_errno(EVT_TAG_OSERROR, errno), NULL); close(sock); return FALSE; } if (self->setup_socket && !self->setup_socket(self, sock)) { close(sock); return FALSE; } self->fd = sock; afsocket_sd_start_watches(self); res = TRUE; } else { if (!self->connections) { if (!afsocket_sd_acquire_socket(self, &sock)) return self->super.super.optional; if (sock == -1 && !afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock)) return self->super.super.optional; } self->fd = -1; if (!self->setup_socket(self, sock)) { close(sock); return FALSE; } /* we either have self->connections != NULL, or sock contains a new fd */ if (self->connections || afsocket_sd_process_connection(self, NULL, self->bind_addr, sock)) res = TRUE; } return res; }
gboolean afsocket_sd_init(LogPipe *s) { AFSocketSourceDriver *self = (AFSocketSourceDriver *) s; gint sock; gboolean res = FALSE; GlobalConfig *cfg = log_pipe_get_config(s); #if ENABLE_SSL if (self->flags & AFSOCKET_REQUIRE_TLS && !self->tls_context) { msg_error("Transport TLS was specified, but TLS related parameters missing", NULL); return FALSE; } #endif if (!self->bind_addr) { msg_error("No bind address set;", NULL); } log_reader_options_init(&self->reader_options, cfg, self->super.group); /* fetch persistent connections first */ if ((self->flags & AFSOCKET_KEEP_ALIVE)) { GList *p; self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE), NULL, NULL); for (p = self->connections; p; p = p->next) { afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self); } } /* ok, we have connection list, check if we need to open a listener */ sock = -1; if (self->flags & AFSOCKET_STREAM) { GSource *source; if (self->flags & AFSOCKET_KEEP_ALIVE) { /* NOTE: this assumes that fd 0 will never be used for listening fds, * main.c opens fd 0 so this assumption can hold */ sock = GPOINTER_TO_UINT(cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, TRUE), NULL, NULL)) - 1; } if (sock == -1) { if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock)) return self->super.optional; } /* set up listening source */ if (listen(sock, self->listen_backlog) < 0) { msg_error("Error during listen()", evt_tag_errno(EVT_TAG_OSERROR, errno), NULL); close(sock); return FALSE; } if (self->setup_socket && !self->setup_socket(self, sock)) { close(sock); return FALSE; } self->fd = sock; source = g_listen_source_new(self->fd); /* the listen_source references us, which is freed when the source is deleted */ log_pipe_ref(s); g_source_set_callback(source, afsocket_sd_accept, self, (GDestroyNotify) log_pipe_unref); self->source_id = g_source_attach(source, NULL); g_source_unref(source); res = TRUE; } else { if (!self->connections) { if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock)) return self->super.optional; } self->fd = -1; if (!self->setup_socket(self, sock)) { close(sock); return FALSE; } /* we either have self->connections != NULL, or sock contains a new fd */ if (self->connections || afsocket_sd_process_connection(self, NULL, self->bind_addr, sock)) res = TRUE; } return res; }