static void
afamqp_dd_free(LogPipe *d)
{
AMQPDestDriver *self = (AMQPDestDriver *) d;
g_mutex_free(self->suspend_mutex);
g_mutex_free(self->queue_mutex);
g_cond_free(self->writer_thread_wakeup_cond);
if (self->queue)
log_queue_unref(self->queue);
g_free(self->exchange);
g_free(self->exchange_type);
log_template_unref(self->routing_key_template);
log_template_unref(self->body_template);
g_free(self->user);
g_free(self->password);
g_free(self->host);
g_free(self->vhost);
g_free(self->entries);
if (self->vp)
value_pairs_free(self->vp);
log_dest_driver_free(d);
}
void
cfg_free(GlobalConfig *self)
{
g_assert(self->persist == NULL);
if (self->state)
persist_state_free(self->state);
g_free(self->file_template_name);
g_free(self->proto_template_name);
log_template_unref(self->file_template);
log_template_unref(self->proto_template);
log_template_options_destroy(&self->template_options);
host_resolve_options_destroy(&self->host_resolve_options);
if (self->bad_hostname_compiled)
regfree(&self->bad_hostname);
g_free(self->bad_hostname_re);
dns_cache_options_destroy(&self->dns_cache_options);
g_free(self->custom_domain);
plugin_free_plugins(self);
plugin_free_candidate_modules(self);
cfg_tree_free_instance(&self->tree);
g_hash_table_unref(self->module_config);
g_free(self);
}
void
fop_cmp_free(FilterExprNode *s)
{
FilterCmp *self = (FilterCmp *) s;
log_template_unref(self->left);
log_template_unref(self->right);
}
void
fop_cmp_free(FilterExprNode *s)
{
FilterCmp *self = (FilterCmp *) s;
log_template_unref(self->left);
log_template_unref(self->right);
g_string_free(self->left_buf, TRUE);
g_string_free(self->right_buf, TRUE);
}
static void
log_rewrite_set_free(LogRewrite *s)
{
LogRewriteSet *self = (LogRewriteSet *) s;
log_template_unref(self->value_template);
}
static void
http_dd_free(LogPipe *s)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *)s;
log_template_options_destroy(&self->template_options);
g_string_free(self->delimiter, TRUE);
g_string_free(self->body_prefix, TRUE);
g_string_free(self->body_suffix, TRUE);
log_template_unref(self->body_template);
curl_global_cleanup();
g_free(self->user);
g_free(self->password);
g_free(self->user_agent);
g_free(self->ca_dir);
g_free(self->ca_file);
g_free(self->cert_file);
g_free(self->key_file);
g_free(self->ciphers);
g_list_free_full(self->headers, g_free);
http_auth_header_free(self->auth_header);
g_mutex_free(self->workers_lock);
http_load_balancer_free(self->load_balancer);
log_threaded_dest_driver_free(s);
}
void
synthetic_context_set_context_id_template(SyntheticContext *self, LogTemplate *context_id_template)
{
if (self->id_template)
log_template_unref(self->id_template);
self->id_template = context_id_template;
}
static void
tf_template_free_state(gpointer s)
{
TFTemplateState *state = (TFTemplateState *) s;
log_template_unref(state->invoked_template);
}
void
http_dd_set_body(LogDriver *d, LogTemplate *body)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *) d;
log_template_unref(self->body_template);
self->body_template = log_template_ref(body);
}
static void
redis_dd_free(LogPipe *d)
{
RedisDriver *self = (RedisDriver *)d;
log_template_options_destroy(&self->template_options);
g_free(self->host);
g_string_free(self->command, TRUE);
log_template_unref(self->key);
log_template_unref(self->param1);
log_template_unref(self->param2);
if (self->c)
redisFree(self->c);
log_threaded_dest_driver_free(d);
}
static void
_free(AddContextualDataSelector *s)
{
AddContextualDataTemplateSelector *self = (AddContextualDataTemplateSelector *)s;
log_template_unref(self->selector_template);
g_free(self->selector_template_string);
g_free(self);
}
void
log_rewrite_subst_free(LogRewrite *s)
{
LogRewriteSubst *self = (LogRewriteSubst *) s;
log_matcher_free(self->matcher);
log_template_unref(self->replacement);
}
static void
tf_graphite_free_state(gpointer s)
{
TFGraphiteState *state = (TFGraphiteState *)s;
if (state->vp)
value_pairs_unref(state->vp);
log_template_unref(state->timestamp_template);
}
void
redis_dd_set_command(LogDriver *d, const gchar *command,
LogTemplate *key,
LogTemplate *param1, LogTemplate *param2)
{
RedisDriver *self = (RedisDriver *)d;
g_string_assign(self->command, command);
log_template_unref(self->key);
self->key = log_template_ref(key);
log_template_unref(self->param1);
self->param1 = log_template_ref(param1);
log_template_unref(self->param2);
self->param2 = log_template_ref(param2);
}
static void
afamqp_dd_free(LogPipe *d)
{
AMQPDestDriver *self = (AMQPDestDriver *) d;
log_template_options_destroy(&self->template_options);
g_free(self->exchange);
g_free(self->exchange_type);
log_template_unref(self->routing_key_template);
log_template_unref(self->body_template);
g_free(self->user);
g_free(self->password);
g_free(self->host);
g_free(self->vhost);
g_free(self->entries);
value_pairs_unref(self->vp);
log_threaded_dest_driver_free(d);
}
void
cfg_free(GlobalConfig *self)
{
g_assert(self->persist == NULL);
if (self->state)
persist_state_free(self->state);
g_free(self->file_template_name);
g_free(self->proto_template_name);
log_template_unref(self->file_template);
log_template_unref(self->proto_template);
if (self->bad_hostname_compiled)
regfree(&self->bad_hostname);
g_free(self->bad_hostname_re);
g_free(self->dns_cache_hosts);
g_list_free(self->plugins);
plugin_free_candidate_modules(self);
cfg_tree_free_instance(&self->tree);
g_free(self);
}
void
tf_simple_func_free_state(gpointer s)
{
TFSimpleFuncState *state = (TFSimpleFuncState *) s;
gint i;
for (i = 0; i < state->argc; i++)
{
if (state->argv[i])
log_template_unref(state->argv[i]);
}
g_free(state->argv);
}
int
testcase_replace(const gchar *log, const gchar *re, gchar *replacement, const gchar *expected_result, const gint matcher_flags, LogMatcher *m)
{
LogMessage *msg;
LogTemplate *r;
gchar *result;
gssize length;
gchar buf[1024];
gssize msglen;
NVHandle nonasciiz = log_msg_get_value_handle("NON-ASCIIZ");
const gchar *value;
GSockAddr *sa;
sa = g_sockaddr_inet_new("10.10.10.10", 1010);
msg = log_msg_new(log, strlen(log), sa, &parse_options);
g_sockaddr_unref(sa);
/* NOTE: we test how our matchers cope with non-zero terminated values. We don't change message_len, only the value */
g_snprintf(buf, sizeof(buf), "%sAAAAAAAAAAAA", log_msg_get_value(msg, LM_V_MESSAGE, &msglen));
log_msg_set_value(msg, log_msg_get_value_handle("MESSAGE2"), buf, -1);
/* add a non-zero terminated indirect value which contains the whole message */
log_msg_set_value_indirect(msg, nonasciiz, log_msg_get_value_handle("MESSAGE2"), 0, 0, msglen);
log_matcher_set_flags(m, matcher_flags);
log_matcher_compile(m, re);
r = log_template_new(configuration, NULL);
log_template_compile(r, replacement, NULL);
NVTable *nv_table = nv_table_ref(msg->payload);
value = log_msg_get_value(msg, nonasciiz, &msglen);
result = log_matcher_replace(m, msg, nonasciiz, value, msglen, r, &length);
value = log_msg_get_value(msg, nonasciiz, &msglen);
nv_table_unref(nv_table);
if (strncmp(result ? result : value, expected_result, result ? length : msglen) != 0)
{
fprintf(stderr, "Testcase failure. pattern=%s, result=%.*s, expected=%s\n", re, (gint) length, result ? result : value, expected_result);
exit(1);
}
g_free(result);
log_template_unref(r);
log_matcher_unref(m);
log_msg_unref(msg);
return 0;
}
void
tf_cond_free_state(TFCondState *args)
{
gint i;
if (args->filter)
filter_expr_unref(args->filter);
for (i = 0; i < args->argc; i++)
{
if (args->argv[i])
log_template_unref(args->argv[i]);
}
g_free(args);
}
static void
afstomp_dd_free(LogPipe *d)
{
STOMPDestDriver *self = (STOMPDestDriver *) d;
log_template_options_destroy(&self->template_options);
g_free(self->destination);
log_template_unref(self->body_template);
g_free(self->user);
g_free(self->password);
g_free(self->host);
if (self->vp)
value_pairs_unref(self->vp);
log_threaded_dest_driver_free(d);
}
gboolean
synthetic_message_add_value_template_string(SyntheticMessage *self, GlobalConfig *cfg, const gchar *name, const gchar *value, GError **error)
{
LogTemplate *value_template;
gboolean result = FALSE;
/* NOTE: we shouldn't use the name property for LogTemplate structs, see the comment at log_template_set_name() */
value_template = log_template_new(cfg, name);
if (log_template_compile(value_template, value, error))
{
synthetic_message_add_value_template(self, name, value_template);
result = TRUE;
}
log_template_unref(value_template);
return result;
}
void
pdb_message_clean(PDBMessage *self)
{
gint i;
if (self->tags)
g_array_free(self->tags, TRUE);
if (self->values)
{
for (i = 0; i < self->values->len; i++)
log_template_unref(g_ptr_array_index(self->values, i));
g_ptr_array_free(self->values, 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;
}
LogMessage *
synthetic_message_generate_without_context(SyntheticMessage *self, LogMessage *msg, GString *buffer)
{
LogMessage *genmsg;
genmsg = _generate_default_message(self->inherit_mode, msg);
/* no context, which means no correllation. The action
* rule contains the generated message at @0 and the one
* which triggered the rule in @1.
*
* We emulate a context having only these two
* messages, but without allocating a full-blown
* structure.
*/
LogMessage *dummy_msgs[] = { msg, genmsg, NULL };
GPtrArray dummy_ptr_array = { .pdata = (void **) dummy_msgs, .len = 2 };
CorrellationContext dummy_context = { .messages = &dummy_ptr_array, 0 };
synthetic_message_apply(self, &dummy_context, genmsg, buffer);
return genmsg;
}
void
synthetic_message_init(SyntheticMessage *self)
{
memset(self, 0, sizeof(*self));
}
void
synthetic_message_deinit(SyntheticMessage *self)
{
gint i;
if (self->tags)
g_array_free(self->tags, TRUE);
if (self->values)
{
for (i = 0; i < self->values->len; i++)
log_template_unref(g_ptr_array_index(self->values, i));
g_ptr_array_free(self->values, TRUE);
}
}
static void
testcase(gchar *msg, goffset offset, gchar *timezone, gchar *format, gchar *expected)
{
LogTemplate *templ;
LogMessage *logmsg;
NVTable *nvtable;
GlobalConfig *cfg = cfg_new (0x302);
LogParser *parser = date_parser_new (cfg);
gboolean success;
const gchar *context_id = "test-context-id";
GString *res = g_string_sized_new(128);
date_parser_set_offset(parser, offset);
if (format != NULL) date_parser_set_format(parser, format);
if (timezone != NULL) date_parser_set_timezone(parser, timezone);
parse_options.flags = 0;
logmsg = log_msg_new_empty();
logmsg->timestamps[LM_TS_RECVD].tv_sec = 1438793384; /* Wed Aug 5 2015 */
log_msg_set_value(logmsg, log_msg_get_value_handle("MESSAGE"), msg, -1);
nvtable = nv_table_ref(logmsg->payload);
success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
nv_table_unref(nvtable);
if (!success)
{
fprintf(stderr, "unable to parse offset=%d format=%s msg=%s\n", offset, format, msg);
exit(1);
}
/* Convert to ISODATE */
templ = compile_template("${ISODATE}", FALSE);
log_template_format(templ, logmsg, NULL, LTZ_LOCAL, 999, context_id, res);
assert_nstring(res->str, res->len, expected, strlen(expected),
"incorrect date parsed msg=%s offset=%d format=%s",
msg, offset, format);
log_template_unref(templ);
g_string_free(res, TRUE);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
return;
}
static void
_replace_template(LogTemplate **old_template, LogTemplate *new_template)
{
log_template_unref(*old_template);
*old_template = log_template_ref(new_template);
}
void
synthetic_context_deinit(SyntheticContext *self)
{
if (self->id_template)
log_template_unref(self->id_template);
}
