← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/syslog-ng/oneiric

« back to all changes in this revision

Viewing changes to src/logrewrite.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2011-05-16 22:02:46 UTC
  • mfrom: (26.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20110516220246-nknmeu831n49bx1z
Tags: 3.2.4-1
* New upstream release, fixing infinite loop via PCRE and global. No CVE
  number yet, Vigil@nce id is 10648.
* Remove all patches, they were applied upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/logrewrite.c
1
 
/*
2
 
 * Copyright (c) 2002-2009 BalaBit IT Ltd, Budapest, Hungary
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify it
5
 
 * under the terms of the GNU General Public License version 2 as published
6
 
 * by the Free Software Foundation.
7
 
 *
8
 
 * Note that this permission is granted for only version 2 of the GPL.
9
 
 *
10
 
 * As an additional exemption you are allowed to compile & link against the
11
 
 * OpenSSL libraries as published by the OpenSSL project. See the file
12
 
 * COPYING for details.
13
 
 *
14
 
 * This program is distributed in the hope that it will be useful,
15
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 * GNU General Public License for more details.
18
 
 *
19
 
 * You should have received a copy of the GNU General Public License
20
 
 * along with this program; if not, write to the Free Software
21
 
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22
 
 */
23
 
 
24
 
#include "logrewrite.h"
25
 
#include "logmsg.h"
26
 
#include "cfg.h"
27
 
#include "templates.h"
28
 
#include "logmatcher.h"
29
 
 
30
 
 
31
 
/* rewrite */
32
 
 
33
 
static void
34
 
log_rewrite_init(LogRewrite *self)
35
 
{
36
 
  self->value_handle = LM_V_MESSAGE;
37
 
}
38
 
 
39
 
void
40
 
log_rewrite_free(LogRewrite *self)
41
 
{
42
 
  self->free_fn(self);
43
 
  g_free(self);
44
 
}
45
 
 
46
 
typedef struct _LogRewriteSubst LogRewriteSubst;
47
 
 
48
 
struct _LogRewriteSubst
49
 
{
50
 
  LogRewrite super;
51
 
  LogMatcher *matcher;
52
 
  LogTemplate *replacement;
53
 
};
54
 
 
55
 
void 
56
 
log_rewrite_subst_process(LogRewrite *s, LogMessage *msg)
57
 
{
58
 
  LogRewriteSubst *self = (LogRewriteSubst *) s;
59
 
  GError *regexp_error;
60
 
  const gchar *value;
61
 
  gchar *new_value;
62
 
  regexp_error = NULL;
63
 
  gssize length;
64
 
  gssize new_length = -1;
65
 
 
66
 
  value = log_msg_get_value(msg, self->super.value_handle, &length);
67
 
 
68
 
  new_value = log_matcher_replace(self->matcher, msg, self->super.value_handle, value, length, self->replacement, &new_length);
69
 
  if (new_value)
70
 
    {
71
 
      log_msg_set_value(msg, self->super.value_handle, new_value, new_length);
72
 
    }
73
 
  g_free(new_value);
74
 
}
75
 
 
76
 
void 
77
 
log_rewrite_subst_free(LogRewrite *s)
78
 
{
79
 
  LogRewriteSubst *self = (LogRewriteSubst *) s;
80
 
  
81
 
  log_matcher_free(self->matcher);
82
 
  log_template_unref(self->replacement);
83
 
}
84
 
 
85
 
LogRewrite *
86
 
log_rewrite_subst_new(const gchar *replacement)
87
 
{
88
 
  LogRewriteSubst *self = g_new0(LogRewriteSubst, 1);
89
 
 
90
 
  log_rewrite_init(&self->super);
91
 
 
92
 
  self->super.free_fn = log_rewrite_subst_free;
93
 
  self->super.process = log_rewrite_subst_process;
94
 
  
95
 
  self->replacement = log_template_new(NULL, replacement);
96
 
  return &self->super;
97
 
}
98
 
 
99
 
gboolean 
100
 
log_rewrite_set_regexp(LogRewrite *s, const gchar *regexp)
101
 
{
102
 
  LogRewriteSubst *self = (LogRewriteSubst*)s;
103
 
  if(!self->matcher)
104
 
    self->matcher = log_matcher_posix_re_new();
105
 
 
106
 
  return log_matcher_compile(self->matcher, regexp);
107
 
}
108
 
 
109
 
void
110
 
log_rewrite_set_flags(LogRewrite *s, gint flags)
111
 
{
112
 
  LogRewriteSubst *self = (LogRewriteSubst*)s;
113
 
 
114
 
  if(!self->matcher)
115
 
    self->matcher = log_matcher_posix_re_new();
116
 
 
117
 
  log_matcher_set_flags(self->matcher, flags);
118
 
}
119
 
 
120
 
typedef struct _LogRewriteSet LogRewriteSet;
121
 
 
122
 
struct _LogRewriteSet
123
 
{
124
 
  LogRewrite super;
125
 
  LogTemplate *value_template;
126
 
};
127
 
 
128
 
static void
129
 
log_rewrite_set_process(LogRewrite *s, LogMessage *msg)
130
 
{
131
 
  LogRewriteSet *self = (LogRewriteSet *) s;
132
 
  GString *result;
133
 
 
134
 
  result = g_string_sized_new(64);
135
 
  log_template_format(self->value_template, msg, 0, TS_FMT_BSD, NULL, 0, 0, result);
136
 
 
137
 
  log_msg_set_value(msg, self->super.value_handle, result->str, result->len);
138
 
  g_string_free(result, TRUE);
139
 
}
140
 
 
141
 
static void
142
 
log_rewrite_set_free(LogRewrite *s)
143
 
{
144
 
  LogRewriteSet *self = (LogRewriteSet *) s;
145
 
 
146
 
  log_template_unref(self->value_template);
147
 
}
148
 
 
149
 
LogRewrite *
150
 
log_rewrite_set_new(const gchar *new_value)
151
 
{
152
 
  LogRewriteSet *self = g_new0(LogRewriteSet, 1);
153
 
  
154
 
  log_rewrite_init(&self->super);
155
 
  self->super.free_fn = log_rewrite_set_free;
156
 
  self->super.process = log_rewrite_set_process;
157
 
 
158
 
  self->value_template = log_template_new(NULL, new_value);
159
 
  
160
 
  return &self->super;
161
 
}
162
 
 
163
 
void
164
 
log_rewrite_set_matcher(LogRewrite *s, LogMatcher *matcher)
165
 
{
166
 
  gint flags = 0;
167
 
  LogRewriteSubst *self = (LogRewriteSubst*)s;
168
 
  if(self->matcher)
169
 
    {
170
 
      flags = self->matcher->flags;
171
 
      log_matcher_free(self->matcher);
172
 
    }
173
 
  self->matcher = matcher;  
174
 
 
175
 
  log_rewrite_set_flags(s, flags);
176
 
}
177
 
 
178
 
typedef struct _LogRewriteRule
179
 
{
180
 
  LogProcessRule super;
181
 
  GList *rewrite_list; /* LogRewrite*  */;
182
 
} LogRewriteRule;
183
 
 
184
 
static void 
185
 
log_rewrite_rule_call_item(gpointer item, gpointer user_data)
186
 
{
187
 
  LogRewrite *r = (LogRewrite *) item;
188
 
  LogMessage *msg = (LogMessage *) user_data;
189
 
  gssize length;
190
 
  const gchar *value;
191
 
 
192
 
  r->process(r, msg);
193
 
  if (G_UNLIKELY(debug_flag))
194
 
    {
195
 
      value = log_msg_get_value(msg, r->value_handle, &length);
196
 
      msg_debug("Rewrite expression evaluation result",
197
 
                evt_tag_str("value", log_msg_get_value_name(r->value_handle, NULL)),
198
 
                evt_tag_printf("new_value", "%.*s", (gint) length, value),
199
 
                NULL);
200
 
    }
201
 
}
202
 
 
203
 
 
204
 
static gboolean
205
 
log_rewrite_rule_process(LogProcessRule *s, LogMessage *msg)
206
 
{
207
 
  LogRewriteRule *self = (LogRewriteRule *) s;
208
 
  
209
 
  g_list_foreach(self->rewrite_list, log_rewrite_rule_call_item, msg);
210
 
 
211
 
  return TRUE;
212
 
}
213
 
 
214
 
 
215
 
static void
216
 
log_rewrite_rule_free(LogProcessRule *s)
217
 
{
218
 
  LogRewriteRule *self = (LogRewriteRule *) s;
219
 
 
220
 
  /* free each item in the list*/
221
 
  g_list_foreach(self->rewrite_list, (GFunc)log_rewrite_free,NULL);
222
 
 
223
 
  /* free the glist */
224
 
  g_list_free(self->rewrite_list);
225
 
  self->rewrite_list = NULL;
226
 
}
227
 
 
228
 
/*
229
 
 * LogRewriteRule, a configuration block encapsulating a LogRewrite instance.
230
 
 */ 
231
 
LogProcessRule *
232
 
log_rewrite_rule_new(const gchar *name, GList *rule_list)
233
 
{
234
 
  LogRewriteRule *self = g_new0(LogRewriteRule, 1);
235
 
  
236
 
  log_process_rule_init(&self->super, name);
237
 
  self->super.free_fn = log_rewrite_rule_free;
238
 
  self->super.process = log_rewrite_rule_process;
239
 
  self->rewrite_list = rule_list;
240
 
  return &self->super;
241
 
}
242