static void _handle_file_created(WildcardSourceDriver *self, const DirectoryMonitorEvent *event) { if (g_pattern_match_string(self->compiled_pattern, event->name)) { WildcardFileReader *reader = g_hash_table_lookup(self->file_readers, event->full_path); if (!reader) { _create_file_reader(self, event->full_path); msg_debug("Wildcard: file created", evt_tag_str("filename", event->full_path)); } else { if (wildcard_file_reader_is_deleted(reader)) { msg_info("File is deleted, new file create with same name. " "While old file is reading, skip the new one", evt_tag_str("filename", event->full_path)); pending_file_list_add(self->waiting_list, event->full_path); } else if (!log_pipe_init(&reader->super.super)) { msg_error("Can not re-initialize reader for file", evt_tag_str("filename", event->full_path)); } else { msg_debug("Wildcard: file reader reinitialized", evt_tag_str("filename", event->full_path)); } } } }
static gboolean afsocket_sc_init(LogPipe *s) { AFSocketSourceConnection *self = (AFSocketSourceConnection *) s; LogTransport *transport; LogProtoServer *proto; if (!self->reader) { transport = afsocket_sd_construct_transport(self->owner, self->sock); proto = log_proto_server_factory_construct(self->owner->proto_factory, transport, &self->owner->reader_options.proto_options.super); self->reader = log_reader_new(proto); } log_reader_set_options(self->reader, s, &self->owner->reader_options, STATS_LEVEL1, self->owner->transport_mapper->stats_source, self->owner->super.super.id, afsocket_sc_stats_instance(self)); log_reader_set_peer_addr(self->reader, self->peer_addr); log_pipe_append((LogPipe *) self->reader, s); if (log_pipe_init((LogPipe *) self->reader, NULL)) { return TRUE; } else { log_pipe_unref((LogPipe *) self->reader); self->reader = NULL; } return FALSE; }
static gboolean afsocket_sd_restore_kept_alive_connections(AFSocketSourceDriver *self) { GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super); /* fetch persistent connections first */ if (self->connections_kept_alive_accross_reloads) { GList *p = NULL; self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE)); self->num_connections = 0; for (p = self->connections; p; p = p->next) { afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self); if (log_pipe_init((LogPipe *) p->data)) { self->num_connections++; } else { AFSocketSourceConnection *sc = (AFSocketSourceConnection *)p->data; self->connections = g_list_remove(self->connections, sc); afsocket_sd_kill_connection((AFSocketSourceConnection *)sc); } } } return TRUE; }
/* NOTE: runs in the main thread */ static void affile_sd_notify(LogPipe *s, gint notify_code, gpointer user_data) { AFFileSourceDriver *self = (AFFileSourceDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); gint fd; switch (notify_code) { case NC_FILE_MOVED: { msg_verbose("Follow-mode file source moved, tracking of the new file is started", evt_tag_str("filename", self->filename->str), NULL); log_pipe_deinit((LogPipe *) self->reader); log_pipe_unref((LogPipe *) self->reader); self->reader = NULL; if (affile_sd_open_file(self, self->filename->str, &fd)) { LogProtoServer *proto; PollEvents *poll_events; poll_events = affile_sd_construct_poll_events(self, fd); if (!poll_events) break; 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); log_reader_set_immediate_check(self->reader); 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); } affile_sd_recover_state(s, cfg, proto); } break; } default: break; } }
static void _setup_dd(void) { dd = test_threaded_dd_new(main_loop_get_current_config(main_loop)); cr_assert(log_pipe_init(&dd->super.super.super.super)); }
static gboolean afprogram_dd_init(LogPipe *s) { AFProgramDestDriver *self = (AFProgramDestDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); if (!log_dest_driver_init_method(s)) return FALSE; log_writer_options_init(&self->writer_options, cfg, 0); if (!self->writer) self->writer = log_writer_new(LW_FORMAT_FILE); log_writer_set_options(self->writer, s, &self->writer_options, STATS_LEVEL0, SCS_PROGRAM, self->super.super.id, self->cmdline->str); log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afprogram_dd_format_persist_name(self))); log_pipe_init((LogPipe *) self->writer, NULL); log_pipe_append(&self->super.super.super, (LogPipe *) self->writer); return afprogram_dd_reopen(self); }
static gboolean afprogram_dd_init(LogPipe *s) { AFProgramDestDriver *self = (AFProgramDestDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); if (!log_dest_driver_init_method(s)) return FALSE; log_writer_options_init(&self->writer_options, cfg, 0); const gboolean restore_successful = afprogram_dd_restore_reload_store_item(self, cfg); if (!self->writer) self->writer = log_writer_new(LW_FORMAT_FILE, s->cfg); log_writer_set_options(self->writer, s, &self->writer_options, STATS_LEVEL0, SCS_PROGRAM, self->super.super.id, self->process_info.cmdline->str); log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afprogram_dd_format_queue_persist_name(self))); if (!log_pipe_init((LogPipe *) self->writer)) { log_pipe_unref((LogPipe *) self->writer); return FALSE; } log_pipe_append(&self->super.super.super, (LogPipe *) self->writer); return restore_successful ? TRUE : afprogram_dd_reopen(self); }
static gboolean log_source_group_init(LogPipe *s) { LogSourceGroup *self = (LogSourceGroup *) s; LogDriver *p; GlobalConfig *cfg = log_pipe_get_config(s); gint id = 0; for (p = self->drivers; p; p = p->drv_next) { p->group = g_strdup(self->name); if (!p->id) p->id = g_strdup_printf("%s#%d", self->name, id++); if (!log_pipe_init(&p->super, cfg)) { msg_error("Error initializing source driver", evt_tag_str("source", self->name), evt_tag_str("id", p->id), NULL); goto deinit_all; } log_pipe_append(&p->super, s); } stats_register_counter(0, SCS_SOURCE | SCS_GROUP, self->name, NULL, SC_TYPE_PROCESSED, &self->processed_messages); return TRUE; deinit_all: for (p = self->drivers; p; p = p->drv_next) log_pipe_deinit(&p->super); return FALSE; }
static gboolean afsocket_dd_setup_writer(AFSocketDestDriver *self) { afsocket_dd_restore_writer(self); if (!self->writer) { /* NOTE: we open our writer with no fd, so we can send messages down there * even while the connection is not established */ self->writer = afsocket_dd_construct_writer(self); } log_writer_set_options(self->writer, &self->super.super.super, &self->writer_options, STATS_LEVEL0, self->transport_mapper->stats_source, self->super.super.id, afsocket_dd_stats_instance(self)); log_writer_set_queue(self->writer, log_dest_driver_acquire_queue( &self->super, afsocket_dd_format_qfile_name(self))); if (!log_pipe_init((LogPipe *) self->writer)) { log_pipe_unref((LogPipe *) self->writer); return FALSE; } log_pipe_append(&self->super.super.super, (LogPipe *) self->writer); return TRUE; }
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; }
/* NOTE: runs in the main thread */ static void affile_sd_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data) { AFFileSourceDriver *self = (AFFileSourceDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); gint fd; switch (notify_code) { case NC_FILE_MOVED: { msg_verbose("Follow-mode file source moved, tracking of the new file is started", evt_tag_str("filename", self->filename->str), NULL); log_pipe_deinit(self->reader); log_pipe_unref(self->reader); if (affile_sd_open_file(self, self->filename->str, &fd)) { LogTransport *transport; LogProto *proto; transport = log_transport_plain_new(fd, 0); transport->timeout = 10; proto = affile_sd_construct_proto(self, transport); self->reader = log_reader_new(proto); log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_FILE, self->super.super.id, self->filename->str); log_reader_set_follow_filename(self->reader, self->filename->str); log_reader_set_immediate_check(self->reader); log_pipe_append(self->reader, s); if (!log_pipe_init(self->reader, cfg)) { msg_error("Error initializing log_reader, closing fd", evt_tag_int("fd", fd), NULL); log_pipe_unref(self->reader); self->reader = NULL; close(fd); } affile_sd_recover_state(s, cfg, proto); } else { self->reader = NULL; } break; } default: break; } }
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 afsocket_dd_init(LogPipe *s) { AFSocketDestDriver *self = (AFSocketDestDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); if (!log_dest_driver_init_method(s)) return FALSE; if (!afsocket_dd_apply_transport(self)) return FALSE; /* these fields must be set up by apply_transport, so let's check if it indeed did */ g_assert(self->transport); g_assert(self->bind_addr); g_assert(self->hostname); g_assert(self->dest_name); if (cfg) { self->time_reopen = cfg->time_reopen; } log_writer_options_init(&self->writer_options, cfg, 0); self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, FALSE)); if (!self->writer) { /* NOTE: we open our writer with no fd, so we can send messages down there * even while the connection is not established */ self->writer = log_writer_new(LW_FORMAT_PROTO | #if ENABLE_SSL (((self->flags & AFSOCKET_STREAM) && !self->tls_context) ? LW_DETECT_EOF : 0) | #else ((self->flags & AFSOCKET_STREAM) ? LW_DETECT_EOF : 0) | #endif (self->flags & AFSOCKET_SYSLOG_PROTOCOL ? LW_SYSLOG_PROTOCOL : 0)); } log_writer_set_options((LogWriter *) self->writer, &self->super.super.super, &self->writer_options, 0, afsocket_dd_stats_source(self), self->super.super.id, afsocket_dd_stats_instance(self)); log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afsocket_dd_format_persist_name(self, TRUE))); log_pipe_init(self->writer, NULL); log_pipe_append(&self->super.super.super, self->writer); if (!log_writer_opened((LogWriter *) self->writer)) afsocket_dd_reconnect(self); return TRUE; }
static LogParser * _construct_parser(gchar *timezone_, gchar *format, gint time_stamp) { LogParser *parser; parser = date_parser_new (configuration); if (format != NULL) date_parser_set_format(parser, format); if (timezone_ != NULL) date_parser_set_timezone(parser, timezone_); date_parser_set_time_stamp(parser, time_stamp); log_pipe_init(&parser->super); return parser; }
static LogParser * create_parser(TestParserOptions *options) { LogParser *snmptrapd_parser = snmptrapd_parser_new(configuration); if (options) { if (options->key_prefix) snmptrapd_parser_set_prefix(snmptrapd_parser, options->key_prefix); snmptrapd_parser_set_set_message_macro(snmptrapd_parser, options->set_message_macro); } log_pipe_init((LogPipe *)snmptrapd_parser); return snmptrapd_parser; }
static gboolean __init(LogPipe *s) { TestSource *self = (TestSource *)s; self->reader = journal_reader_new(configuration, self->journald_mock); journal_reader_options_defaults(&self->options); if (self->current_test_case && self->current_test_case->init) { self->current_test_case->init(self->current_test_case, self, self->journald_mock, self->reader, &self->options); } journal_reader_options_init(&self->options, configuration, "test"); journal_reader_set_options((LogPipe *)self->reader, &self->super, &self->options, 3, SCS_JOURNALD, "test", "1"); log_pipe_append((LogPipe *)self->reader, &self->super); assert_true(log_pipe_init((LogPipe *)self->reader), ASSERTION_ERROR("Can't initialize reader")); return TRUE; }
gboolean afsocket_dd_init(LogPipe *s) { AFSocketDestDriver *self = (AFSocketDestDriver *) s; 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 self->error_logged = FALSE; if (cfg) { self->time_reopen = cfg->time_reopen; } if (!self->writer) { log_writer_options_init(&self->writer_options, cfg, 0); /* NOTE: we open our writer with no fd, so we can send messages down there * even while the connection is not established */ if ((self->flags & AFSOCKET_KEEP_ALIVE)) self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, self->dest_name, FALSE)); if (!self->writer) self->writer = log_writer_new(LW_FORMAT_PROTO | #if ENABLE_SSL (((self->flags & AFSOCKET_STREAM) && !self->tls_context) ? LW_DETECT_EOF : 0) | #else ((self->flags & AFSOCKET_STREAM) ? LW_DETECT_EOF : 0) | #endif (self->flags & AFSOCKET_SYSLOG_PROTOCOL ? LW_SYSLOG_PROTOCOL : 0)); log_writer_set_options((LogWriter *) self->writer, &self->super.super, &self->writer_options, 0, afsocket_dd_stats_source(self), self->super.id, afsocket_dd_stats_instance(self)); log_pipe_init(self->writer, NULL); log_pipe_append(&self->super.super, self->writer); } afsocket_dd_reconnect(self); return TRUE; }
static void testcase(gchar *msg, gchar *timezone, gchar *format, gchar *expected) { LogTemplate *templ; LogMessage *logmsg; LogParser *parser; gboolean success; GString *res = g_string_sized_new(128); parser = date_parser_new (configuration); if (format != NULL) date_parser_set_format(parser, format); if (timezone != NULL) date_parser_set_timezone(parser, timezone); log_pipe_init(&parser->super); logmsg = log_msg_new_empty(); logmsg->timestamps[LM_TS_RECVD].tv_sec = 1451473200; /* Dec 30 2015 */ log_msg_set_value(logmsg, log_msg_get_value_handle("MESSAGE"), msg, -1); success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1); if (!success && expected) { fprintf(stderr, "unable to parse format=%s msg=%s\n", format, msg); exit(1); } else if (success && !expected) { fprintf(stderr, "successfully parsed but expected failure, format=%s msg=%s\n", format, msg); exit(1); } else if (expected) { /* Convert to ISODATE */ templ = compile_template("${ISODATE}", FALSE); log_template_format(templ, logmsg, NULL, LTZ_LOCAL, -1, NULL, res); assert_nstring(res->str, res->len, expected, strlen(expected), "incorrect date parsed msg=%s format=%s", msg, format); log_template_unref(templ); } g_string_free(res, TRUE); log_pipe_unref(&parser->super); log_msg_unref(logmsg); return; }
Test(logthrdestdrv, test_connect_failure_kicks_in_suspend_retry_logic_which_keeps_reconnecting_until_successful) { /* the dd created by setup() is not good for us */ _teardown_dd(); /* we are asserting on a debug message */ debug_flag = TRUE; start_grabbing_messages(); dd = test_threaded_dd_new(main_loop_get_current_config(main_loop)); dd->super.worker.connect = _connect_failure; dd->super.worker.insert = _insert_single_message_success; dd->super.time_reopen = 0; cr_assert(log_pipe_init(&dd->super.super.super.super)); _generate_message_and_wait_for_processing(dd, dd->super.written_messages); cr_assert(dd->connect_counter == 11, "%d", dd->connect_counter); assert_grabbed_log_contains("Error establishing connection to server"); }
static void afprogram_dd_exit(pid_t pid, int status, gpointer s) { AFProgramDestDriver *self = (AFProgramDestDriver *) s; /* Note: self->pid being -1 means that deinit was called, thus we don't * need to restart the command. self->pid might change due to EPIPE * handling restarting the command before this handler is run. */ if (self->pid != -1 && self->pid == pid) { msg_verbose("Child program exited, restarting", evt_tag_str("cmdline", self->cmdline->str), evt_tag_int("status", status), NULL); self->pid = -1; log_pipe_deinit(&self->super.super, NULL, NULL); log_pipe_init(&self->super.super, NULL, NULL); } }
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 afinter_sd_init(LogPipe *s) { AFInterSourceDriver *self = (AFInterSourceDriver *) s; GlobalConfig *cfg = log_pipe_get_config(s); if (!log_src_driver_init_method(s)) return FALSE; if (current_internal_source != NULL) { msg_error("Multiple internal() sources were detected, this is not possible", NULL); return FALSE; } log_source_options_init(&self->source_options, cfg, self->super.group); self->source = afinter_source_new(self, &self->source_options); log_pipe_append(&self->source->super, s); log_pipe_init(&self->source->super, cfg); return TRUE; }
static LogMessage * parse_geoip_into_log_message_no_check(const gchar *input) { LogMessage *msg; LogPathOptions path_options = LOG_PATH_OPTIONS_INIT; LogParser *cloned_parser; gboolean success; cloned_parser = (LogParser *) log_pipe_clone(&geoip_parser->super); log_pipe_init(&cloned_parser->super); msg = log_msg_new_empty(); log_msg_set_value(msg, LM_V_MESSAGE, input, -1); success = log_parser_process_message(cloned_parser, &msg, &path_options); if (!success) { log_msg_unref(msg); msg = NULL; } log_pipe_deinit(&cloned_parser->super); log_pipe_unref(&cloned_parser->super); return msg; }
static gboolean __init(LogPipe *s) { SystemdJournalSourceDriver *self = (SystemdJournalSourceDriver *)s; GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super); self->reader = journal_reader_new(cfg, self->journald); journal_reader_options_init(&self->reader_options, cfg, self->super.super.group); journal_reader_set_options((LogPipe *)self->reader, &self->super.super.super, &self->reader_options, 0, SCS_JOURNALD, self->super.super.id, "journal"); log_pipe_append((LogPipe *)self->reader, &self->super.super.super); if (!log_pipe_init((LogPipe *)self->reader)) { msg_error("Error initializing journal_reader"); log_pipe_unref((LogPipe *) self->reader); self->reader = NULL; return FALSE; } return TRUE; }
void _create_file_reader(WildcardSourceDriver *self, const gchar *full_path) { WildcardFileReader *reader = NULL; GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super); if (g_hash_table_size(self->file_readers) >= self->max_files) { msg_warning("Number of allowed monitorod file is reached, rejecting read file", evt_tag_str("source", self->super.super.group), evt_tag_str("filename", full_path), evt_tag_int("max_files", self->max_files)); pending_file_list_add(self->waiting_list, full_path); return; } reader = wildcard_file_reader_new(full_path, &self->file_reader_options, self->file_opener, &self->super, cfg); wildcard_file_reader_on_deleted_file_finished(reader, _remove_file_reader, self); wildcard_file_reader_on_deleted_file_eof(reader, _stop_file_reader, self); log_pipe_append(&reader->super.super, &self->super.super.super); if (!log_pipe_init(&reader->super.super)) { msg_warning("File reader initialization failed", evt_tag_str("filename", full_path), evt_tag_str("source_driver", self->super.super.group)); log_pipe_unref(&reader->super.super); } else { g_hash_table_insert(self->file_readers, g_strdup(full_path), reader); } }
static gboolean trigger_sd_init (LogPipe *s) { TriggerSourceDriver *self = (TriggerSourceDriver *)s; GlobalConfig *cfg = log_pipe_get_config (s); if (!log_src_driver_init_method (s)) return FALSE; if (self->options.trigger_freq <= 0) self->options.trigger_freq = 10; if (!self->options.message) self->options.message = g_strdup ("Trigger source is trigger happy."); log_source_options_init (&self->source_options, cfg, self->super.super.group); self->source = trigger_source_new (self, &self->source_options, cfg); log_pipe_append (&self->source->super, s); log_pipe_init (&self->source->super); 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 void __start_source(gpointer user_data) { TestSource *self = (TestSource *)user_data; log_pipe_init(&self->super); }
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 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; }