Debian Codegraph @

src/utils/message_parser/message_parser.c

raw
1 /*
2 * collectd - src/utils/message_parser/message_parser.c
3 * MIT License
4 *
5 * Copyright(c) 2017-2018 Intel Corporation. All rights reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
24 *
25 * Authors:
26 * Krzysztof Matczak <[email protected]>
27 * Marcin Mozejko <[email protected]>
28 */
29
30 #include "collectd.h"
31
32 #include "plugin.h"
33 #include "utils/common/common.h"
34
35 #include "utils/message_parser/message_parser.h"
36
37 #define UTIL_NAME "utils_message_parser"
38
39 #define MSG_STOR_INIT_LEN 64
40 #define MSG_STOR_INC_STEP 10
41
42 typedef struct checked_match_s {
43 parser_job_data_t *parser_job;
44 message_pattern_t msg_pattern;
45 int msg_pattern_idx;
46 } checked_match_t;
47
48 struct parser_job_data_s {
49 const char *filename;
50 unsigned int start_idx;
51 unsigned int stop_idx;
52 cu_tail_match_t *tm;
53 message_t *messages_storage;
54 size_t messages_max_len;
55 int message_idx;
56 unsigned int message_item_idx;
57 unsigned int messages_completed;
58 message_pattern_t *message_patterns;
59 size_t message_patterns_len;
60 int (*resize_message_buffer)(parser_job_data_t *self, size_t);
61 int (*start_message_assembly)(parser_job_data_t *self);
62 void (*end_message_assembly)(parser_job_data_t *self);
63 void (*message_item_assembly)(parser_job_data_t *self, checked_match_t *cm,
64 char *const *matches);
65 };
66
67 static void message_item_assembly(parser_job_data_t *self, checked_match_t *cm,
68 char *const *matches) {
69 message_item_t *msg_it = &self->messages_storage[self->message_idx]
70 .message_items[self->message_item_idx];
71 sstrncpy(msg_it->name, cm->msg_pattern.name, sizeof(msg_it->name));
72 sstrncpy(msg_it->value, matches[cm->msg_pattern.submatch_idx],
73 sizeof(msg_it->value));
74 msg_it->user_data = cm->msg_pattern.user_data;
75 msg_it->free_user_data = cm->msg_pattern.free_user_data;
76 ++(self->message_item_idx);
77 }
78
79 static int start_message_assembly(parser_job_data_t *self) {
80 /* Remove previous message assembly if unfinished */
81 if (self->message_idx >= 0 &&
82 self->messages_storage[self->message_idx].started == true &&
83 self->messages_storage[self->message_idx].completed == false) {
84 DEBUG(UTIL_NAME ": Removing unfinished assembly of previous message");
85 self->messages_storage[self->message_idx] = (message_t){{{{0}}}};
86 self->message_item_idx = 0;
87 } else
88 ++(self->message_idx);
89
90 /* Resize messages buffer if needed */
91 if (self->message_idx >= self->messages_max_len) {
92 INFO(UTIL_NAME ": Exceeded message buffer size: %zu",
93 self->messages_max_len);
94 if (self->resize_message_buffer(self, self->messages_max_len +
95 MSG_STOR_INC_STEP) != 0) {
96 ERROR(UTIL_NAME ": Insufficient message buffer size: %zu. Remaining "
97 "messages for this read will be skipped",
98 self->messages_max_len);
99 self->message_idx = self->messages_max_len;
100 return -1;
101 }
102 }
103 self->messages_storage[self->message_idx] = (message_t){{{{0}}}};
104 self->message_item_idx = 0;
105 self->messages_storage[self->message_idx].started = true;
106 self->messages_storage[self->message_idx].completed = false;
107 return 0;
108 }
109
110 static int resize_message_buffer(parser_job_data_t *self, size_t new_size) {
111 INFO(UTIL_NAME ": Resizing message buffer size to %zu", new_size);
112 void *new_storage = realloc(self->messages_storage,
113 new_size * sizeof(*self->messages_storage));
114 if (new_storage == NULL) {
115 ERROR(UTIL_NAME ": Error while reallocating message buffer");
116 return -1;
117 }
118 self->messages_storage = new_storage;
119 self->messages_max_len = new_size;
120 /* Fill unused memory with 0 */
121 unsigned int unused_idx = self->message_idx < 0 ? 0 : self->message_idx;
122 memset(self->messages_storage + unused_idx, 0,
123 (self->messages_max_len - unused_idx) *
124 sizeof(*self->messages_storage));
125 return 0;
126 }
127
128 static void end_message_assembly(parser_job_data_t *self) {
129 /* Checking mandatory items */
130 for (size_t i = 0; i < self->message_patterns_len; i++) {
131 if (self->message_patterns[i].is_mandatory &&
132 !(self->messages_storage[self->message_idx]
133 .matched_patterns_check[i])) {
134 WARNING(
135 UTIL_NAME
136 ": Mandatory message item pattern %s not found. Message discarded",
137 self->message_patterns[i].regex);
138 self->messages_storage[self->message_idx] = (message_t){{{{0}}}};
139 self->message_item_idx = 0;
140 if (self->message_idx > 0)
141 --(self->message_idx);
142 return;
143 }
144 }
145 self->messages_storage[self->message_idx].completed = true;
146 ++self->messages_completed;
147 self->message_item_idx = 0;
148 }
149
150 static int message_assembler(const char *row, char *const *matches,
151 size_t matches_num, void *user_data) {
152 if (user_data == NULL) {
153 ERROR(UTIL_NAME ": Invalid user_data pointer");
154 return -1;
155 }
156 checked_match_t *cm = (checked_match_t *)user_data;
157 parser_job_data_t *parser_job = cm->parser_job;
158
159 if (cm->msg_pattern.submatch_idx < -1 ||
160 cm->msg_pattern.submatch_idx >= (int)matches_num) {
161 ERROR(UTIL_NAME ": Invalid target submatch index: %d",
162 cm->msg_pattern.submatch_idx);
163 return -1;
164 }
165 if (parser_job->message_item_idx >=
166 STATIC_ARRAY_SIZE(parser_job->messages_storage[parser_job->message_idx]
167 .message_items)) {
168 ERROR(UTIL_NAME ": Message items number exceeded. Forced message end.");
169 parser_job->end_message_assembly(parser_job);
170 return -1;
171 }
172
173 /* Every matched start pattern resets current message items and starts
174 * assembling new messages */
175 if (strcmp(cm->msg_pattern.regex,
176 parser_job->message_patterns[parser_job->start_idx].regex) == 0) {
177 DEBUG(UTIL_NAME ": Found beginning pattern");
178 if (parser_job->start_message_assembly(parser_job) != 0)
179 return -1;
180 }
181 /* Ignoring message items without corresponding start item or
182 * after completion */
183 if (parser_job->message_idx < 0 ||
184 parser_job->messages_storage[parser_job->message_idx].started == false ||
185 parser_job->messages_storage[parser_job->message_idx].completed == true) {
186 DEBUG(UTIL_NAME ": Dropping item with no corresponding start element");
187 return 0;
188 }
189 /* Populate message items */
190 if (cm->msg_pattern.submatch_idx >= 0)
191 parser_job->message_item_assembly(parser_job, cm, matches);
192
193 /* Mark pattern as checked */
194 parser_job->messages_storage[parser_job->message_idx]
195 .matched_patterns_check[cm->msg_pattern_idx] = 1;
196
197 /* Handle message ending */
198 if (strcmp(cm->msg_pattern.regex,
199 parser_job->message_patterns[parser_job->stop_idx].regex) == 0) {
200 DEBUG(UTIL_NAME ": Found ending pattern");
201 parser_job->end_message_assembly(parser_job);
202 }
203 return 0;
204 }
205
206 parser_job_data_t *message_parser_init(const char *filename,
207 unsigned int start_idx,
208 unsigned int stop_idx,
209 message_pattern_t message_patterns[],
210 size_t message_patterns_len) {
211 parser_job_data_t *parser_job = calloc(1, sizeof(*parser_job));
212 if (parser_job == NULL) {
213 ERROR(UTIL_NAME ": Error allocating parser_job");
214 return NULL;
215 }
216 parser_job->resize_message_buffer = resize_message_buffer;
217 parser_job->start_message_assembly = start_message_assembly;
218 parser_job->end_message_assembly = end_message_assembly;
219 parser_job->message_item_assembly = message_item_assembly;
220 parser_job->messages_max_len = MSG_STOR_INIT_LEN;
221 parser_job->filename = filename;
222 parser_job->start_idx = start_idx;
223 parser_job->stop_idx = stop_idx;
224 parser_job->message_idx = -1;
225 parser_job->messages_completed = 0;
226 parser_job->message_patterns =
227 calloc(message_patterns_len, sizeof(*parser_job->message_patterns));
228 if (parser_job->message_patterns == NULL) {
229 ERROR(UTIL_NAME ": Error allocating message_patterns");
230 goto free_parser_job;
231 }
232 parser_job->messages_storage = calloc(parser_job->messages_max_len,
233 sizeof(*parser_job->messages_storage));
234 if (parser_job->messages_storage == NULL) {
235 ERROR(UTIL_NAME ": Error allocating messages_storage");
236 goto free_msg_patterns;
237 }
238 /* Crete own copy of regex patterns */
239 memcpy(parser_job->message_patterns, message_patterns,
240 sizeof(*parser_job->message_patterns) * message_patterns_len);
241 parser_job->message_patterns_len = message_patterns_len;
242 /* Init tail match */
243 parser_job->tm = tail_match_create(parser_job->filename);
244 if (parser_job->tm == NULL) {
245 ERROR(UTIL_NAME ": Error creating tail match");
246 goto free_msg_storage;
247 }
248
249 for (size_t i = 0; i < message_patterns_len; i++) {
250 /* Create current_match container for passing regex info
251 * to callback function */
252 checked_match_t *current_match = calloc(1, sizeof(*current_match));
253 if (current_match == NULL) {
254 ERROR(UTIL_NAME ": Error allocating current_match");
255 goto free_tail_match;
256 }
257 current_match->parser_job = parser_job;
258 current_match->msg_pattern = message_patterns[i];
259 current_match->msg_pattern_idx = i;
260 /* Create callback */
261 cu_match_t *m = match_create_callback(
262 message_patterns[i].regex, message_patterns[i].excluderegex,
263 message_assembler, current_match, free);
264 if (m == NULL) {
265 ERROR(UTIL_NAME ": Error creating match callback");
266 goto free_tail_match;
267 }
268 if (tail_match_add_match(parser_job->tm, m, 0, 0, 0) != 0) {
269 ERROR(UTIL_NAME ": Error adding match callback");
270 goto free_tail_match;
271 }
272 }
273
274 return parser_job;
275
276 free_tail_match:
277 tail_match_destroy(parser_job->tm);
278 free_msg_storage:
279 sfree(parser_job->messages_storage);
280 free_msg_patterns:
281 sfree(parser_job->message_patterns);
282 free_parser_job:
283 sfree(parser_job);
284
285 return NULL;
286 }
287
288 int message_parser_read(parser_job_data_t *parser_job,
289 message_t **messages_storage, bool force_rewind) {
290 if (parser_job == NULL) {
291 ERROR(UTIL_NAME ": Invalid parser_job pointer");
292 return -1;
293 }
294 parser_job->messages_completed = 0;
295 bool incomplete_msg_found = false;
296 /* Finish incomplete message assembly in this read */
297 if (parser_job->message_idx >= 0 &&
298 parser_job->messages_storage[parser_job->message_idx].started &&
299 !(parser_job->messages_storage[parser_job->message_idx].completed)) {
300 INFO(UTIL_NAME ": Found incomplete message from previous read.");
301 incomplete_msg_found = true;
302 message_t tmp_message =
303 parser_job->messages_storage[parser_job->message_idx];
304 int tmp_message_item_idx = parser_job->message_item_idx;
305 memset(parser_job->messages_storage, 0,
306 parser_job->messages_max_len *
307 sizeof(*parser_job->messages_storage));
308 memcpy(parser_job->messages_storage, &tmp_message,
309 sizeof(*parser_job->messages_storage));
310 parser_job->message_item_idx = tmp_message_item_idx;
311 parser_job->message_idx = 0;
312 }
313 /* Reset message buffer after non empty read */
314 else if (parser_job->message_idx >= 0) {
315 memset(parser_job->messages_storage, 0,
316 parser_job->messages_max_len *
317 sizeof(*parser_job->messages_storage));
318 parser_job->message_item_idx = 0;
319 parser_job->message_idx = -1;
320 }
321
322 int status = tail_match_read(parser_job->tm, force_rewind);
323 if (status != 0) {
324 ERROR(UTIL_NAME ": Error while parser read. Status: %d", status);
325 return -1;
326 }
327
328 /* Restore initial message buffer size if there's nothing to parse */
329 if (parser_job->messages_completed == 0 &&
330 parser_job->messages_max_len > MSG_STOR_INIT_LEN && !incomplete_msg_found)
331 parser_job->resize_message_buffer(parser_job, MSG_STOR_INIT_LEN);
332
333 *messages_storage = parser_job->messages_storage;
334 return parser_job->messages_completed;
335 }
336
337 void message_parser_cleanup(parser_job_data_t *parser_job) {
338 if (parser_job == NULL) {
339 ERROR(UTIL_NAME ": Invalid parser_job pointer");
340 return;
341 }
342 sfree(parser_job->messages_storage);
343 sfree(parser_job->message_patterns);
344 if (parser_job->tm)
345 tail_match_destroy(parser_job->tm);
346 sfree(parser_job);
347 }