1
2 /*****
3 *
4 * Copyright (C) 2001-2015 CS-SI. All Rights Reserved.
5 * Author: Yoann Vandoorselaere <yoann.v@prelude-ids.com>
6 * Author: Nicolas Delon <nicolas.delon@prelude-ids.com>
7 *
8 * This file is part of the Prelude library.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 *
24 *****/
25
26 /* Auto-generated by the GenerateIDMEFMessageReadC package */
27 #include "config.h"
28
29 #include <stdio.h>
30 #include <unistd.h>
31
32 #define PRELUDE_ERROR_SOURCE_DEFAULT PRELUDE_ERROR_SOURCE_IDMEF_MESSAGE_READ
33 #include "prelude-error.h"
34 #include "prelude-inttypes.h"
35 #include "prelude-list.h"
36 #include "prelude-extract.h"
37 #include "prelude-io.h"
38 #include "idmef-message-id.h"
39 #include "idmef.h"
40 #include "idmef-tree-wrap.h"
41
42 #include "idmef-message-read.h"
43
44 #define prelude_extract_string_safe(out, buf, len, msg) extract_string_safe_f(__FUNCTION__, __LINE__, out, buf, len)
45
extract_string_safe_f(const char * f,int line,prelude_string_t ** out,char * buf,size_t len)46 static inline int extract_string_safe_f(const char *f, int line, prelude_string_t **out, char *buf, size_t len)
47 {
48 int ret;
49
50 /*
51 * we use len - 1 since len is supposed to include \0 to avoid making a dup.
52 */
53 ret = prelude_string_new_ref_fast(out, buf, len - 1);
54 if ( ret < 0 )
55 ret = prelude_error_verbose(prelude_error_get_code(ret), "%s:%d could not extract IDMEF string: %s", f, line, prelude_strerror(ret));
56
57 return ret;
58 }
59
60
prelude_extract_time_safe(idmef_time_t ** out,void * buf,size_t len,prelude_msg_t * msg)61 static inline int prelude_extract_time_safe(idmef_time_t **out, void *buf, size_t len, prelude_msg_t *msg)
62 {
63 int ret;
64
65 /*
66 * sizeof(sec) + sizeof(usec) + sizeof(gmt offset).
67 */
68 if ( len != 12 )
69 return prelude_error_make(PRELUDE_ERROR_SOURCE_EXTRACT, PRELUDE_ERROR_INVAL_IDMEF_TIME);
70
71 ret = idmef_time_new(out);
72 if ( ret < 0 )
73 return ret;
74
75 idmef_time_set_sec(*out, prelude_extract_uint32(buf));
76 idmef_time_set_usec(*out, prelude_extract_uint32((unsigned char *) buf + 4));
77 idmef_time_set_gmt_offset(*out, prelude_extract_int32((unsigned char *) buf + 8));
78
79 return 0;
80 }
81
82
prelude_extract_data_safe(idmef_data_t ** out,void * buf,uint32_t len,prelude_msg_t * msg)83 static inline int prelude_extract_data_safe(idmef_data_t **out, void *buf, uint32_t len, prelude_msg_t *msg)
84 {
85 int ret;
86 uint8_t tag;
87 idmef_data_type_t type = 0;
88
89 ret = prelude_extract_uint32_safe(&type, buf, len);
90 if ( ret < 0 )
91 return ret;
92
93 ret = prelude_msg_get(msg, &tag, &len, &buf);
94 if ( ret < 0 )
95 return ret;
96
97 *out = NULL;
98
99 switch ( type ) {
100 case IDMEF_DATA_TYPE_CHAR: {
101 uint8_t tmp = 0;
102
103 ret = prelude_extract_uint8_safe(&tmp, buf, len);
104 if ( ret < 0 )
105 return ret;
106
107 ret = idmef_data_new_char(out, (char) tmp);
108 break;
109 }
110
111 case IDMEF_DATA_TYPE_BYTE: {
112 uint8_t tmp = 0;
113
114 ret = prelude_extract_uint8_safe(&tmp, buf, len);
115 if ( ret < 0 )
116 return ret;
117
118 ret = idmef_data_new_byte(out, tmp);
119 break;
120 }
121
122 case IDMEF_DATA_TYPE_UINT32: {
123 uint32_t tmp = 0;
124
125 ret = prelude_extract_uint32_safe(&tmp, buf, len);
126 if ( ret < 0 )
127 return ret;
128
129 ret = idmef_data_new_int(out, tmp);
130 break;
131 }
132
133 case IDMEF_DATA_TYPE_INT: {
134 uint64_t tmp = 0;
135
136 ret = prelude_extract_uint64_safe(&tmp, buf, len);
137 if ( ret < 0 )
138 return ret;
139
140 ret = idmef_data_new_int(out, tmp);
141 break;
142 }
143
144 case IDMEF_DATA_TYPE_FLOAT: {
145 float tmp = 0;
146
147 ret = prelude_extract_float_safe(&tmp, buf, len);
148 if ( ret < 0 )
149 return ret;
150
151 ret = idmef_data_new_float(out, tmp);
152 break;
153 }
154
155 case IDMEF_DATA_TYPE_BYTE_STRING: {
156 ret = idmef_data_new_ptr_ref_fast(out, type, buf, len);
157 break;
158 }
159
160 case IDMEF_DATA_TYPE_CHAR_STRING: {
161 const char *tmp = NULL;
162
163 ret = prelude_extract_characters_safe(&tmp, buf, len);
164 if ( ret < 0 )
165 return ret;
166
167 ret = idmef_data_new_ptr_ref_fast(out, type, tmp, len);
168 break;
169 }
170
171 case IDMEF_DATA_TYPE_TIME: {
172 idmef_time_t *time;
173
174 ret = prelude_extract_time_safe(&time, buf, len, msg);
175 if ( ret < 0 )
176 return ret;
177
178 ret = idmef_data_new_time(out, time);
179 break;
180 }
181
182 case IDMEF_DATA_TYPE_UNKNOWN:
183 /* nop */;
184 }
185
186 return ret;
187 }
188
189
190
191 /**
192 * idmef_additional_data_read:
193 * @additional_data: Pointer to a #idmef_additional_data_t object.
194 * @msg: Pointer to a #prelude_msg_t object, containing a message.
195 *
196 * Read an idmef_additional_data from the @msg message, and
197 * store it into @additional_data.
198 *
199 * Returns: 0 on success, a negative value if an error occured.
200 */
idmef_additional_data_read(idmef_additional_data_t * additional_data,prelude_msg_t * msg)201 int idmef_additional_data_read(idmef_additional_data_t *additional_data, prelude_msg_t *msg)
202 {
203 int ret;
204 void *buf;
205 uint8_t tag;
206 uint32_t len;
207
208 while ( 1 ) {
209 ret = prelude_msg_get(msg, &tag, &len, &buf);
210 if ( ret < 0 )
211 return ret;
212
213 switch ( tag ) {
214
215 case IDMEF_MSG_ADDITIONAL_DATA_MEANING: {
216 prelude_string_t *tmp = NULL;
217
218 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
219 if ( ret < 0 )
220 return ret;
221
222 idmef_additional_data_set_meaning(additional_data, tmp);
223 break;
224 }
225
226 case IDMEF_MSG_ADDITIONAL_DATA_TYPE: {
227 int32_t tmp = 0;
228
229 ret = prelude_extract_int32_safe(&tmp, buf, len);
230 if ( ret < 0 )
231 return ret;
232
233 idmef_additional_data_set_type(additional_data, tmp);
234 break;
235 }
236
237 case IDMEF_MSG_ADDITIONAL_DATA_DATA: {
238 idmef_data_t *tmp = NULL;
239
240 ret = prelude_extract_data_safe(&tmp, buf, len, msg);
241 if ( ret < 0 )
242 return ret;
243
244 idmef_additional_data_set_data(additional_data, tmp);
245 break;
246 }
247
248 case IDMEF_MSG_END_OF_TAG:
249 return 0;
250
251 default:
252 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_additional_data_t: '%u'", tag);
253 }
254
255 }
256
257 return 0;
258 }
259
260 /**
261 * idmef_reference_read:
262 * @reference: Pointer to a #idmef_reference_t object.
263 * @msg: Pointer to a #prelude_msg_t object, containing a message.
264 *
265 * Read an idmef_reference from the @msg message, and
266 * store it into @reference.
267 *
268 * Returns: 0 on success, a negative value if an error occured.
269 */
idmef_reference_read(idmef_reference_t * reference,prelude_msg_t * msg)270 int idmef_reference_read(idmef_reference_t *reference, prelude_msg_t *msg)
271 {
272 int ret;
273 void *buf;
274 uint8_t tag;
275 uint32_t len;
276
277 while ( 1 ) {
278 ret = prelude_msg_get(msg, &tag, &len, &buf);
279 if ( ret < 0 )
280 return ret;
281
282 switch ( tag ) {
283
284 case IDMEF_MSG_REFERENCE_ORIGIN: {
285 int32_t tmp = 0;
286
287 ret = prelude_extract_int32_safe(&tmp, buf, len);
288 if ( ret < 0 )
289 return ret;
290
291 idmef_reference_set_origin(reference, tmp);
292 break;
293 }
294
295 case IDMEF_MSG_REFERENCE_NAME: {
296 prelude_string_t *tmp = NULL;
297
298 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
299 if ( ret < 0 )
300 return ret;
301
302 idmef_reference_set_name(reference, tmp);
303 break;
304 }
305
306 case IDMEF_MSG_REFERENCE_URL: {
307 prelude_string_t *tmp = NULL;
308
309 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
310 if ( ret < 0 )
311 return ret;
312
313 idmef_reference_set_url(reference, tmp);
314 break;
315 }
316
317 case IDMEF_MSG_REFERENCE_MEANING: {
318 prelude_string_t *tmp = NULL;
319
320 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
321 if ( ret < 0 )
322 return ret;
323
324 idmef_reference_set_meaning(reference, tmp);
325 break;
326 }
327
328 case IDMEF_MSG_END_OF_TAG:
329 return 0;
330
331 default:
332 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_reference_t: '%u'", tag);
333 }
334
335 }
336
337 return 0;
338 }
339
340 /**
341 * idmef_classification_read:
342 * @classification: Pointer to a #idmef_classification_t object.
343 * @msg: Pointer to a #prelude_msg_t object, containing a message.
344 *
345 * Read an idmef_classification from the @msg message, and
346 * store it into @classification.
347 *
348 * Returns: 0 on success, a negative value if an error occured.
349 */
idmef_classification_read(idmef_classification_t * classification,prelude_msg_t * msg)350 int idmef_classification_read(idmef_classification_t *classification, prelude_msg_t *msg)
351 {
352 int ret;
353 void *buf;
354 uint8_t tag;
355 uint32_t len;
356
357 while ( 1 ) {
358 ret = prelude_msg_get(msg, &tag, &len, &buf);
359 if ( ret < 0 )
360 return ret;
361
362 switch ( tag ) {
363
364 case IDMEF_MSG_CLASSIFICATION_IDENT: {
365 prelude_string_t *tmp = NULL;
366
367 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
368 if ( ret < 0 )
369 return ret;
370
371 idmef_classification_set_ident(classification, tmp);
372 break;
373 }
374
375 case IDMEF_MSG_CLASSIFICATION_TEXT: {
376 prelude_string_t *tmp = NULL;
377
378 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
379 if ( ret < 0 )
380 return ret;
381
382 idmef_classification_set_text(classification, tmp);
383 break;
384 }
385
386 case IDMEF_MSG_REFERENCE_TAG: {
387 int ret;
388 idmef_reference_t *tmp = NULL;
389
390 ret = idmef_classification_new_reference(classification, &tmp, -1);
391 if ( ret < 0 )
392 return ret;
393
394
395
396 ret = idmef_reference_read(tmp, msg);
397 if ( ret < 0 )
398 return ret;
399
400 break;
401 }
402
403 case IDMEF_MSG_END_OF_TAG:
404 return 0;
405
406 default:
407 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_classification_t: '%u'", tag);
408 }
409
410 }
411
412 return 0;
413 }
414
415 /**
416 * idmef_user_id_read:
417 * @user_id: Pointer to a #idmef_user_id_t object.
418 * @msg: Pointer to a #prelude_msg_t object, containing a message.
419 *
420 * Read an idmef_user_id from the @msg message, and
421 * store it into @user_id.
422 *
423 * Returns: 0 on success, a negative value if an error occured.
424 */
idmef_user_id_read(idmef_user_id_t * user_id,prelude_msg_t * msg)425 int idmef_user_id_read(idmef_user_id_t *user_id, prelude_msg_t *msg)
426 {
427 int ret;
428 void *buf;
429 uint8_t tag;
430 uint32_t len;
431
432 while ( 1 ) {
433 ret = prelude_msg_get(msg, &tag, &len, &buf);
434 if ( ret < 0 )
435 return ret;
436
437 switch ( tag ) {
438
439 case IDMEF_MSG_USER_ID_IDENT: {
440 prelude_string_t *tmp = NULL;
441
442 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
443 if ( ret < 0 )
444 return ret;
445
446 idmef_user_id_set_ident(user_id, tmp);
447 break;
448 }
449
450 case IDMEF_MSG_USER_ID_TYPE: {
451 int32_t tmp = 0;
452
453 ret = prelude_extract_int32_safe(&tmp, buf, len);
454 if ( ret < 0 )
455 return ret;
456
457 idmef_user_id_set_type(user_id, tmp);
458 break;
459 }
460
461 case IDMEF_MSG_USER_ID_TTY: {
462 prelude_string_t *tmp = NULL;
463
464 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
465 if ( ret < 0 )
466 return ret;
467
468 idmef_user_id_set_tty(user_id, tmp);
469 break;
470 }
471
472 case IDMEF_MSG_USER_ID_NAME: {
473 prelude_string_t *tmp = NULL;
474
475 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
476 if ( ret < 0 )
477 return ret;
478
479 idmef_user_id_set_name(user_id, tmp);
480 break;
481 }
482
483 case IDMEF_MSG_USER_ID_NUMBER: {
484 uint32_t tmp = 0;
485
486 ret = prelude_extract_uint32_safe(&tmp, buf, len);
487 if ( ret < 0 )
488 return ret;
489
490 idmef_user_id_set_number(user_id, tmp);
491 break;
492 }
493
494 case IDMEF_MSG_END_OF_TAG:
495 return 0;
496
497 default:
498 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_user_id_t: '%u'", tag);
499 }
500
501 }
502
503 return 0;
504 }
505
506 /**
507 * idmef_user_read:
508 * @user: Pointer to a #idmef_user_t object.
509 * @msg: Pointer to a #prelude_msg_t object, containing a message.
510 *
511 * Read an idmef_user from the @msg message, and
512 * store it into @user.
513 *
514 * Returns: 0 on success, a negative value if an error occured.
515 */
idmef_user_read(idmef_user_t * user,prelude_msg_t * msg)516 int idmef_user_read(idmef_user_t *user, prelude_msg_t *msg)
517 {
518 int ret;
519 void *buf;
520 uint8_t tag;
521 uint32_t len;
522
523 while ( 1 ) {
524 ret = prelude_msg_get(msg, &tag, &len, &buf);
525 if ( ret < 0 )
526 return ret;
527
528 switch ( tag ) {
529
530 case IDMEF_MSG_USER_IDENT: {
531 prelude_string_t *tmp = NULL;
532
533 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
534 if ( ret < 0 )
535 return ret;
536
537 idmef_user_set_ident(user, tmp);
538 break;
539 }
540
541 case IDMEF_MSG_USER_CATEGORY: {
542 int32_t tmp = 0;
543
544 ret = prelude_extract_int32_safe(&tmp, buf, len);
545 if ( ret < 0 )
546 return ret;
547
548 idmef_user_set_category(user, tmp);
549 break;
550 }
551
552 case IDMEF_MSG_USER_ID_TAG: {
553 int ret;
554 idmef_user_id_t *tmp = NULL;
555
556 ret = idmef_user_new_user_id(user, &tmp, -1);
557 if ( ret < 0 )
558 return ret;
559
560
561
562 ret = idmef_user_id_read(tmp, msg);
563 if ( ret < 0 )
564 return ret;
565
566 break;
567 }
568
569 case IDMEF_MSG_END_OF_TAG:
570 return 0;
571
572 default:
573 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_user_t: '%u'", tag);
574 }
575
576 }
577
578 return 0;
579 }
580
581 /**
582 * idmef_address_read:
583 * @address: Pointer to a #idmef_address_t object.
584 * @msg: Pointer to a #prelude_msg_t object, containing a message.
585 *
586 * Read an idmef_address from the @msg message, and
587 * store it into @address.
588 *
589 * Returns: 0 on success, a negative value if an error occured.
590 */
idmef_address_read(idmef_address_t * address,prelude_msg_t * msg)591 int idmef_address_read(idmef_address_t *address, prelude_msg_t *msg)
592 {
593 int ret;
594 void *buf;
595 uint8_t tag;
596 uint32_t len;
597
598 while ( 1 ) {
599 ret = prelude_msg_get(msg, &tag, &len, &buf);
600 if ( ret < 0 )
601 return ret;
602
603 switch ( tag ) {
604
605 case IDMEF_MSG_ADDRESS_IDENT: {
606 prelude_string_t *tmp = NULL;
607
608 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
609 if ( ret < 0 )
610 return ret;
611
612 idmef_address_set_ident(address, tmp);
613 break;
614 }
615
616 case IDMEF_MSG_ADDRESS_CATEGORY: {
617 int32_t tmp = 0;
618
619 ret = prelude_extract_int32_safe(&tmp, buf, len);
620 if ( ret < 0 )
621 return ret;
622
623 idmef_address_set_category(address, tmp);
624 break;
625 }
626
627 case IDMEF_MSG_ADDRESS_VLAN_NAME: {
628 prelude_string_t *tmp = NULL;
629
630 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
631 if ( ret < 0 )
632 return ret;
633
634 idmef_address_set_vlan_name(address, tmp);
635 break;
636 }
637
638 case IDMEF_MSG_ADDRESS_VLAN_NUM: {
639 int32_t tmp = 0;
640
641 ret = prelude_extract_int32_safe(&tmp, buf, len);
642 if ( ret < 0 )
643 return ret;
644
645 idmef_address_set_vlan_num(address, tmp);
646 break;
647 }
648
649 case IDMEF_MSG_ADDRESS_ADDRESS: {
650 prelude_string_t *tmp = NULL;
651
652 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
653 if ( ret < 0 )
654 return ret;
655
656 idmef_address_set_address(address, tmp);
657 break;
658 }
659
660 case IDMEF_MSG_ADDRESS_NETMASK: {
661 prelude_string_t *tmp = NULL;
662
663 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
664 if ( ret < 0 )
665 return ret;
666
667 idmef_address_set_netmask(address, tmp);
668 break;
669 }
670
671 case IDMEF_MSG_END_OF_TAG:
672 return 0;
673
674 default:
675 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_address_t: '%u'", tag);
676 }
677
678 }
679
680 return 0;
681 }
682
683 /**
684 * idmef_process_read:
685 * @process: Pointer to a #idmef_process_t object.
686 * @msg: Pointer to a #prelude_msg_t object, containing a message.
687 *
688 * Read an idmef_process from the @msg message, and
689 * store it into @process.
690 *
691 * Returns: 0 on success, a negative value if an error occured.
692 */
idmef_process_read(idmef_process_t * process,prelude_msg_t * msg)693 int idmef_process_read(idmef_process_t *process, prelude_msg_t *msg)
694 {
695 int ret;
696 void *buf;
697 uint8_t tag;
698 uint32_t len;
699
700 while ( 1 ) {
701 ret = prelude_msg_get(msg, &tag, &len, &buf);
702 if ( ret < 0 )
703 return ret;
704
705 switch ( tag ) {
706
707 case IDMEF_MSG_PROCESS_IDENT: {
708 prelude_string_t *tmp = NULL;
709
710 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
711 if ( ret < 0 )
712 return ret;
713
714 idmef_process_set_ident(process, tmp);
715 break;
716 }
717
718 case IDMEF_MSG_PROCESS_NAME: {
719 prelude_string_t *tmp = NULL;
720
721 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
722 if ( ret < 0 )
723 return ret;
724
725 idmef_process_set_name(process, tmp);
726 break;
727 }
728
729 case IDMEF_MSG_PROCESS_PID: {
730 uint32_t tmp = 0;
731
732 ret = prelude_extract_uint32_safe(&tmp, buf, len);
733 if ( ret < 0 )
734 return ret;
735
736 idmef_process_set_pid(process, tmp);
737 break;
738 }
739
740 case IDMEF_MSG_PROCESS_PATH: {
741 prelude_string_t *tmp = NULL;
742
743 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
744 if ( ret < 0 )
745 return ret;
746
747 idmef_process_set_path(process, tmp);
748 break;
749 }
750
751 case IDMEF_MSG_PROCESS_ARG: {
752 prelude_string_t *tmp = NULL;
753
754 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
755 if ( ret < 0 )
756 return ret;
757
758 idmef_process_set_arg(process, tmp, -1);
759 break;
760 }
761
762 case IDMEF_MSG_PROCESS_ENV: {
763 prelude_string_t *tmp = NULL;
764
765 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
766 if ( ret < 0 )
767 return ret;
768
769 idmef_process_set_env(process, tmp, -1);
770 break;
771 }
772
773 case IDMEF_MSG_END_OF_TAG:
774 return 0;
775
776 default:
777 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_process_t: '%u'", tag);
778 }
779
780 }
781
782 return 0;
783 }
784
785 /**
786 * idmef_web_service_read:
787 * @web_service: Pointer to a #idmef_web_service_t object.
788 * @msg: Pointer to a #prelude_msg_t object, containing a message.
789 *
790 * Read an idmef_web_service from the @msg message, and
791 * store it into @web_service.
792 *
793 * Returns: 0 on success, a negative value if an error occured.
794 */
idmef_web_service_read(idmef_web_service_t * web_service,prelude_msg_t * msg)795 int idmef_web_service_read(idmef_web_service_t *web_service, prelude_msg_t *msg)
796 {
797 int ret;
798 void *buf;
799 uint8_t tag;
800 uint32_t len;
801
802 while ( 1 ) {
803 ret = prelude_msg_get(msg, &tag, &len, &buf);
804 if ( ret < 0 )
805 return ret;
806
807 switch ( tag ) {
808
809 case IDMEF_MSG_WEB_SERVICE_URL: {
810 prelude_string_t *tmp = NULL;
811
812 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
813 if ( ret < 0 )
814 return ret;
815
816 idmef_web_service_set_url(web_service, tmp);
817 break;
818 }
819
820 case IDMEF_MSG_WEB_SERVICE_CGI: {
821 prelude_string_t *tmp = NULL;
822
823 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
824 if ( ret < 0 )
825 return ret;
826
827 idmef_web_service_set_cgi(web_service, tmp);
828 break;
829 }
830
831 case IDMEF_MSG_WEB_SERVICE_HTTP_METHOD: {
832 prelude_string_t *tmp = NULL;
833
834 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
835 if ( ret < 0 )
836 return ret;
837
838 idmef_web_service_set_http_method(web_service, tmp);
839 break;
840 }
841
842 case IDMEF_MSG_WEB_SERVICE_ARG: {
843 prelude_string_t *tmp = NULL;
844
845 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
846 if ( ret < 0 )
847 return ret;
848
849 idmef_web_service_set_arg(web_service, tmp, -1);
850 break;
851 }
852
853 case IDMEF_MSG_END_OF_TAG:
854 return 0;
855
856 default:
857 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_web_service_t: '%u'", tag);
858 }
859
860 }
861
862 return 0;
863 }
864
865 /**
866 * idmef_snmp_service_read:
867 * @snmp_service: Pointer to a #idmef_snmp_service_t object.
868 * @msg: Pointer to a #prelude_msg_t object, containing a message.
869 *
870 * Read an idmef_snmp_service from the @msg message, and
871 * store it into @snmp_service.
872 *
873 * Returns: 0 on success, a negative value if an error occured.
874 */
idmef_snmp_service_read(idmef_snmp_service_t * snmp_service,prelude_msg_t * msg)875 int idmef_snmp_service_read(idmef_snmp_service_t *snmp_service, prelude_msg_t *msg)
876 {
877 int ret;
878 void *buf;
879 uint8_t tag;
880 uint32_t len;
881
882 while ( 1 ) {
883 ret = prelude_msg_get(msg, &tag, &len, &buf);
884 if ( ret < 0 )
885 return ret;
886
887 switch ( tag ) {
888
889 case IDMEF_MSG_SNMP_SERVICE_OID: {
890 prelude_string_t *tmp = NULL;
891
892 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
893 if ( ret < 0 )
894 return ret;
895
896 idmef_snmp_service_set_oid(snmp_service, tmp);
897 break;
898 }
899
900 case IDMEF_MSG_SNMP_SERVICE_MESSAGE_PROCESSING_MODEL: {
901 uint32_t tmp = 0;
902
903 ret = prelude_extract_uint32_safe(&tmp, buf, len);
904 if ( ret < 0 )
905 return ret;
906
907 idmef_snmp_service_set_message_processing_model(snmp_service, tmp);
908 break;
909 }
910
911 case IDMEF_MSG_SNMP_SERVICE_SECURITY_MODEL: {
912 uint32_t tmp = 0;
913
914 ret = prelude_extract_uint32_safe(&tmp, buf, len);
915 if ( ret < 0 )
916 return ret;
917
918 idmef_snmp_service_set_security_model(snmp_service, tmp);
919 break;
920 }
921
922 case IDMEF_MSG_SNMP_SERVICE_SECURITY_NAME: {
923 prelude_string_t *tmp = NULL;
924
925 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
926 if ( ret < 0 )
927 return ret;
928
929 idmef_snmp_service_set_security_name(snmp_service, tmp);
930 break;
931 }
932
933 case IDMEF_MSG_SNMP_SERVICE_SECURITY_LEVEL: {
934 uint32_t tmp = 0;
935
936 ret = prelude_extract_uint32_safe(&tmp, buf, len);
937 if ( ret < 0 )
938 return ret;
939
940 idmef_snmp_service_set_security_level(snmp_service, tmp);
941 break;
942 }
943
944 case IDMEF_MSG_SNMP_SERVICE_CONTEXT_NAME: {
945 prelude_string_t *tmp = NULL;
946
947 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
948 if ( ret < 0 )
949 return ret;
950
951 idmef_snmp_service_set_context_name(snmp_service, tmp);
952 break;
953 }
954
955 case IDMEF_MSG_SNMP_SERVICE_CONTEXT_ENGINE_ID: {
956 prelude_string_t *tmp = NULL;
957
958 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
959 if ( ret < 0 )
960 return ret;
961
962 idmef_snmp_service_set_context_engine_id(snmp_service, tmp);
963 break;
964 }
965
966 case IDMEF_MSG_SNMP_SERVICE_COMMAND: {
967 prelude_string_t *tmp = NULL;
968
969 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
970 if ( ret < 0 )
971 return ret;
972
973 idmef_snmp_service_set_command(snmp_service, tmp);
974 break;
975 }
976
977 case IDMEF_MSG_SNMP_SERVICE_COMMUNITY: {
978 prelude_string_t *tmp = NULL;
979
980 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
981 if ( ret < 0 )
982 return ret;
983
984 idmef_snmp_service_set_community(snmp_service, tmp);
985 break;
986 }
987
988 case IDMEF_MSG_END_OF_TAG:
989 return 0;
990
991 default:
992 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_snmp_service_t: '%u'", tag);
993 }
994
995 }
996
997 return 0;
998 }
999
1000 /**
1001 * idmef_service_read:
1002 * @service: Pointer to a #idmef_service_t object.
1003 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1004 *
1005 * Read an idmef_service from the @msg message, and
1006 * store it into @service.
1007 *
1008 * Returns: 0 on success, a negative value if an error occured.
1009 */
idmef_service_read(idmef_service_t * service,prelude_msg_t * msg)1010 int idmef_service_read(idmef_service_t *service, prelude_msg_t *msg)
1011 {
1012 int ret;
1013 void *buf;
1014 uint8_t tag;
1015 uint32_t len;
1016
1017 while ( 1 ) {
1018 ret = prelude_msg_get(msg, &tag, &len, &buf);
1019 if ( ret < 0 )
1020 return ret;
1021
1022 switch ( tag ) {
1023
1024 case IDMEF_MSG_SERVICE_IDENT: {
1025 prelude_string_t *tmp = NULL;
1026
1027 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1028 if ( ret < 0 )
1029 return ret;
1030
1031 idmef_service_set_ident(service, tmp);
1032 break;
1033 }
1034
1035 case IDMEF_MSG_SERVICE_IP_VERSION: {
1036 uint8_t tmp = 0;
1037
1038 ret = prelude_extract_uint8_safe(&tmp, buf, len);
1039 if ( ret < 0 )
1040 return ret;
1041
1042 idmef_service_set_ip_version(service, tmp);
1043 break;
1044 }
1045
1046 case IDMEF_MSG_SERVICE_IANA_PROTOCOL_NUMBER: {
1047 uint8_t tmp = 0;
1048
1049 ret = prelude_extract_uint8_safe(&tmp, buf, len);
1050 if ( ret < 0 )
1051 return ret;
1052
1053 idmef_service_set_iana_protocol_number(service, tmp);
1054 break;
1055 }
1056
1057 case IDMEF_MSG_SERVICE_IANA_PROTOCOL_NAME: {
1058 prelude_string_t *tmp = NULL;
1059
1060 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1061 if ( ret < 0 )
1062 return ret;
1063
1064 idmef_service_set_iana_protocol_name(service, tmp);
1065 break;
1066 }
1067
1068 case IDMEF_MSG_SERVICE_NAME: {
1069 prelude_string_t *tmp = NULL;
1070
1071 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1072 if ( ret < 0 )
1073 return ret;
1074
1075 idmef_service_set_name(service, tmp);
1076 break;
1077 }
1078
1079 case IDMEF_MSG_SERVICE_PORT: {
1080 uint16_t tmp = 0;
1081
1082 ret = prelude_extract_uint16_safe(&tmp, buf, len);
1083 if ( ret < 0 )
1084 return ret;
1085
1086 idmef_service_set_port(service, tmp);
1087 break;
1088 }
1089
1090 case IDMEF_MSG_SERVICE_PORTLIST: {
1091 prelude_string_t *tmp = NULL;
1092
1093 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1094 if ( ret < 0 )
1095 return ret;
1096
1097 idmef_service_set_portlist(service, tmp);
1098 break;
1099 }
1100
1101 case IDMEF_MSG_SERVICE_PROTOCOL: {
1102 prelude_string_t *tmp = NULL;
1103
1104 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1105 if ( ret < 0 )
1106 return ret;
1107
1108 idmef_service_set_protocol(service, tmp);
1109 break;
1110 }
1111
1112 case IDMEF_MSG_WEB_SERVICE_TAG: {
1113 int ret;
1114 idmef_web_service_t *tmp = NULL;
1115
1116 ret = idmef_service_new_web_service(service, &tmp);
1117 if ( ret < 0 )
1118 return ret;
1119
1120
1121
1122 ret = idmef_web_service_read(tmp, msg);
1123 if ( ret < 0 )
1124 return ret;
1125
1126 break;
1127 }
1128
1129 case IDMEF_MSG_SNMP_SERVICE_TAG: {
1130 int ret;
1131 idmef_snmp_service_t *tmp = NULL;
1132
1133 ret = idmef_service_new_snmp_service(service, &tmp);
1134 if ( ret < 0 )
1135 return ret;
1136
1137
1138
1139 ret = idmef_snmp_service_read(tmp, msg);
1140 if ( ret < 0 )
1141 return ret;
1142
1143 break;
1144 }
1145
1146 case IDMEF_MSG_END_OF_TAG:
1147 return 0;
1148
1149 default:
1150 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_service_t: '%u'", tag);
1151 }
1152
1153 }
1154
1155 return 0;
1156 }
1157
1158 /**
1159 * idmef_node_read:
1160 * @node: Pointer to a #idmef_node_t object.
1161 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1162 *
1163 * Read an idmef_node from the @msg message, and
1164 * store it into @node.
1165 *
1166 * Returns: 0 on success, a negative value if an error occured.
1167 */
idmef_node_read(idmef_node_t * node,prelude_msg_t * msg)1168 int idmef_node_read(idmef_node_t *node, prelude_msg_t *msg)
1169 {
1170 int ret;
1171 void *buf;
1172 uint8_t tag;
1173 uint32_t len;
1174
1175 while ( 1 ) {
1176 ret = prelude_msg_get(msg, &tag, &len, &buf);
1177 if ( ret < 0 )
1178 return ret;
1179
1180 switch ( tag ) {
1181
1182 case IDMEF_MSG_NODE_IDENT: {
1183 prelude_string_t *tmp = NULL;
1184
1185 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1186 if ( ret < 0 )
1187 return ret;
1188
1189 idmef_node_set_ident(node, tmp);
1190 break;
1191 }
1192
1193 case IDMEF_MSG_NODE_CATEGORY: {
1194 int32_t tmp = 0;
1195
1196 ret = prelude_extract_int32_safe(&tmp, buf, len);
1197 if ( ret < 0 )
1198 return ret;
1199
1200 idmef_node_set_category(node, tmp);
1201 break;
1202 }
1203
1204 case IDMEF_MSG_NODE_LOCATION: {
1205 prelude_string_t *tmp = NULL;
1206
1207 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1208 if ( ret < 0 )
1209 return ret;
1210
1211 idmef_node_set_location(node, tmp);
1212 break;
1213 }
1214
1215 case IDMEF_MSG_NODE_NAME: {
1216 prelude_string_t *tmp = NULL;
1217
1218 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1219 if ( ret < 0 )
1220 return ret;
1221
1222 idmef_node_set_name(node, tmp);
1223 break;
1224 }
1225
1226 case IDMEF_MSG_ADDRESS_TAG: {
1227 int ret;
1228 idmef_address_t *tmp = NULL;
1229
1230 ret = idmef_node_new_address(node, &tmp, -1);
1231 if ( ret < 0 )
1232 return ret;
1233
1234
1235
1236 ret = idmef_address_read(tmp, msg);
1237 if ( ret < 0 )
1238 return ret;
1239
1240 break;
1241 }
1242
1243 case IDMEF_MSG_END_OF_TAG:
1244 return 0;
1245
1246 default:
1247 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_node_t: '%u'", tag);
1248 }
1249
1250 }
1251
1252 return 0;
1253 }
1254
1255 /**
1256 * idmef_source_read:
1257 * @source: Pointer to a #idmef_source_t object.
1258 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1259 *
1260 * Read an idmef_source from the @msg message, and
1261 * store it into @source.
1262 *
1263 * Returns: 0 on success, a negative value if an error occured.
1264 */
idmef_source_read(idmef_source_t * source,prelude_msg_t * msg)1265 int idmef_source_read(idmef_source_t *source, prelude_msg_t *msg)
1266 {
1267 int ret;
1268 void *buf;
1269 uint8_t tag;
1270 uint32_t len;
1271
1272 while ( 1 ) {
1273 ret = prelude_msg_get(msg, &tag, &len, &buf);
1274 if ( ret < 0 )
1275 return ret;
1276
1277 switch ( tag ) {
1278
1279 case IDMEF_MSG_SOURCE_IDENT: {
1280 prelude_string_t *tmp = NULL;
1281
1282 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1283 if ( ret < 0 )
1284 return ret;
1285
1286 idmef_source_set_ident(source, tmp);
1287 break;
1288 }
1289
1290 case IDMEF_MSG_SOURCE_SPOOFED: {
1291 int32_t tmp = 0;
1292
1293 ret = prelude_extract_int32_safe(&tmp, buf, len);
1294 if ( ret < 0 )
1295 return ret;
1296
1297 idmef_source_set_spoofed(source, tmp);
1298 break;
1299 }
1300
1301 case IDMEF_MSG_SOURCE_INTERFACE: {
1302 prelude_string_t *tmp = NULL;
1303
1304 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1305 if ( ret < 0 )
1306 return ret;
1307
1308 idmef_source_set_interface(source, tmp);
1309 break;
1310 }
1311
1312 case IDMEF_MSG_NODE_TAG: {
1313 int ret;
1314 idmef_node_t *tmp = NULL;
1315
1316 ret = idmef_source_new_node(source, &tmp);
1317 if ( ret < 0 )
1318 return ret;
1319
1320
1321
1322 ret = idmef_node_read(tmp, msg);
1323 if ( ret < 0 )
1324 return ret;
1325
1326 break;
1327 }
1328
1329 case IDMEF_MSG_USER_TAG: {
1330 int ret;
1331 idmef_user_t *tmp = NULL;
1332
1333 ret = idmef_source_new_user(source, &tmp);
1334 if ( ret < 0 )
1335 return ret;
1336
1337
1338
1339 ret = idmef_user_read(tmp, msg);
1340 if ( ret < 0 )
1341 return ret;
1342
1343 break;
1344 }
1345
1346 case IDMEF_MSG_PROCESS_TAG: {
1347 int ret;
1348 idmef_process_t *tmp = NULL;
1349
1350 ret = idmef_source_new_process(source, &tmp);
1351 if ( ret < 0 )
1352 return ret;
1353
1354
1355
1356 ret = idmef_process_read(tmp, msg);
1357 if ( ret < 0 )
1358 return ret;
1359
1360 break;
1361 }
1362
1363 case IDMEF_MSG_SERVICE_TAG: {
1364 int ret;
1365 idmef_service_t *tmp = NULL;
1366
1367 ret = idmef_source_new_service(source, &tmp);
1368 if ( ret < 0 )
1369 return ret;
1370
1371
1372
1373 ret = idmef_service_read(tmp, msg);
1374 if ( ret < 0 )
1375 return ret;
1376
1377 break;
1378 }
1379
1380 case IDMEF_MSG_END_OF_TAG:
1381 return 0;
1382
1383 default:
1384 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_source_t: '%u'", tag);
1385 }
1386
1387 }
1388
1389 return 0;
1390 }
1391
1392 /**
1393 * idmef_file_access_read:
1394 * @file_access: Pointer to a #idmef_file_access_t object.
1395 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1396 *
1397 * Read an idmef_file_access from the @msg message, and
1398 * store it into @file_access.
1399 *
1400 * Returns: 0 on success, a negative value if an error occured.
1401 */
idmef_file_access_read(idmef_file_access_t * file_access,prelude_msg_t * msg)1402 int idmef_file_access_read(idmef_file_access_t *file_access, prelude_msg_t *msg)
1403 {
1404 int ret;
1405 void *buf;
1406 uint8_t tag;
1407 uint32_t len;
1408
1409 while ( 1 ) {
1410 ret = prelude_msg_get(msg, &tag, &len, &buf);
1411 if ( ret < 0 )
1412 return ret;
1413
1414 switch ( tag ) {
1415
1416 case IDMEF_MSG_USER_ID_TAG: {
1417 int ret;
1418 idmef_user_id_t *tmp = NULL;
1419
1420 ret = idmef_file_access_new_user_id(file_access, &tmp);
1421 if ( ret < 0 )
1422 return ret;
1423
1424
1425
1426 ret = idmef_user_id_read(tmp, msg);
1427 if ( ret < 0 )
1428 return ret;
1429
1430 break;
1431 }
1432
1433 case IDMEF_MSG_FILE_ACCESS_PERMISSION: {
1434 prelude_string_t *tmp = NULL;
1435
1436 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1437 if ( ret < 0 )
1438 return ret;
1439
1440 idmef_file_access_set_permission(file_access, tmp, -1);
1441 break;
1442 }
1443
1444 case IDMEF_MSG_END_OF_TAG:
1445 return 0;
1446
1447 default:
1448 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_file_access_t: '%u'", tag);
1449 }
1450
1451 }
1452
1453 return 0;
1454 }
1455
1456 /**
1457 * idmef_inode_read:
1458 * @inode: Pointer to a #idmef_inode_t object.
1459 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1460 *
1461 * Read an idmef_inode from the @msg message, and
1462 * store it into @inode.
1463 *
1464 * Returns: 0 on success, a negative value if an error occured.
1465 */
idmef_inode_read(idmef_inode_t * inode,prelude_msg_t * msg)1466 int idmef_inode_read(idmef_inode_t *inode, prelude_msg_t *msg)
1467 {
1468 int ret;
1469 void *buf;
1470 uint8_t tag;
1471 uint32_t len;
1472
1473 while ( 1 ) {
1474 ret = prelude_msg_get(msg, &tag, &len, &buf);
1475 if ( ret < 0 )
1476 return ret;
1477
1478 switch ( tag ) {
1479
1480 case IDMEF_MSG_INODE_CHANGE_TIME: {
1481 idmef_time_t *tmp = NULL;
1482
1483 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
1484 if ( ret < 0 )
1485 return ret;
1486
1487 idmef_inode_set_change_time(inode, tmp);
1488 break;
1489 }
1490
1491 case IDMEF_MSG_INODE_NUMBER: {
1492 uint32_t tmp = 0;
1493
1494 ret = prelude_extract_uint32_safe(&tmp, buf, len);
1495 if ( ret < 0 )
1496 return ret;
1497
1498 idmef_inode_set_number(inode, tmp);
1499 break;
1500 }
1501
1502 case IDMEF_MSG_INODE_MAJOR_DEVICE: {
1503 uint32_t tmp = 0;
1504
1505 ret = prelude_extract_uint32_safe(&tmp, buf, len);
1506 if ( ret < 0 )
1507 return ret;
1508
1509 idmef_inode_set_major_device(inode, tmp);
1510 break;
1511 }
1512
1513 case IDMEF_MSG_INODE_MINOR_DEVICE: {
1514 uint32_t tmp = 0;
1515
1516 ret = prelude_extract_uint32_safe(&tmp, buf, len);
1517 if ( ret < 0 )
1518 return ret;
1519
1520 idmef_inode_set_minor_device(inode, tmp);
1521 break;
1522 }
1523
1524 case IDMEF_MSG_INODE_C_MAJOR_DEVICE: {
1525 uint32_t tmp = 0;
1526
1527 ret = prelude_extract_uint32_safe(&tmp, buf, len);
1528 if ( ret < 0 )
1529 return ret;
1530
1531 idmef_inode_set_c_major_device(inode, tmp);
1532 break;
1533 }
1534
1535 case IDMEF_MSG_INODE_C_MINOR_DEVICE: {
1536 uint32_t tmp = 0;
1537
1538 ret = prelude_extract_uint32_safe(&tmp, buf, len);
1539 if ( ret < 0 )
1540 return ret;
1541
1542 idmef_inode_set_c_minor_device(inode, tmp);
1543 break;
1544 }
1545
1546 case IDMEF_MSG_END_OF_TAG:
1547 return 0;
1548
1549 default:
1550 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_inode_t: '%u'", tag);
1551 }
1552
1553 }
1554
1555 return 0;
1556 }
1557
1558 /**
1559 * idmef_checksum_read:
1560 * @checksum: Pointer to a #idmef_checksum_t object.
1561 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1562 *
1563 * Read an idmef_checksum from the @msg message, and
1564 * store it into @checksum.
1565 *
1566 * Returns: 0 on success, a negative value if an error occured.
1567 */
idmef_checksum_read(idmef_checksum_t * checksum,prelude_msg_t * msg)1568 int idmef_checksum_read(idmef_checksum_t *checksum, prelude_msg_t *msg)
1569 {
1570 int ret;
1571 void *buf;
1572 uint8_t tag;
1573 uint32_t len;
1574
1575 while ( 1 ) {
1576 ret = prelude_msg_get(msg, &tag, &len, &buf);
1577 if ( ret < 0 )
1578 return ret;
1579
1580 switch ( tag ) {
1581
1582 case IDMEF_MSG_CHECKSUM_VALUE: {
1583 prelude_string_t *tmp = NULL;
1584
1585 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1586 if ( ret < 0 )
1587 return ret;
1588
1589 idmef_checksum_set_value(checksum, tmp);
1590 break;
1591 }
1592
1593 case IDMEF_MSG_CHECKSUM_KEY: {
1594 prelude_string_t *tmp = NULL;
1595
1596 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1597 if ( ret < 0 )
1598 return ret;
1599
1600 idmef_checksum_set_key(checksum, tmp);
1601 break;
1602 }
1603
1604 case IDMEF_MSG_CHECKSUM_ALGORITHM: {
1605 int32_t tmp = 0;
1606
1607 ret = prelude_extract_int32_safe(&tmp, buf, len);
1608 if ( ret < 0 )
1609 return ret;
1610
1611 idmef_checksum_set_algorithm(checksum, tmp);
1612 break;
1613 }
1614
1615 case IDMEF_MSG_END_OF_TAG:
1616 return 0;
1617
1618 default:
1619 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_checksum_t: '%u'", tag);
1620 }
1621
1622 }
1623
1624 return 0;
1625 }
1626
1627 /**
1628 * idmef_file_read:
1629 * @file: Pointer to a #idmef_file_t object.
1630 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1631 *
1632 * Read an idmef_file from the @msg message, and
1633 * store it into @file.
1634 *
1635 * Returns: 0 on success, a negative value if an error occured.
1636 */
idmef_file_read(idmef_file_t * file,prelude_msg_t * msg)1637 int idmef_file_read(idmef_file_t *file, prelude_msg_t *msg)
1638 {
1639 int ret;
1640 void *buf;
1641 uint8_t tag;
1642 uint32_t len;
1643
1644 while ( 1 ) {
1645 ret = prelude_msg_get(msg, &tag, &len, &buf);
1646 if ( ret < 0 )
1647 return ret;
1648
1649 switch ( tag ) {
1650
1651 case IDMEF_MSG_FILE_IDENT: {
1652 prelude_string_t *tmp = NULL;
1653
1654 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1655 if ( ret < 0 )
1656 return ret;
1657
1658 idmef_file_set_ident(file, tmp);
1659 break;
1660 }
1661
1662 case IDMEF_MSG_FILE_NAME: {
1663 prelude_string_t *tmp = NULL;
1664
1665 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1666 if ( ret < 0 )
1667 return ret;
1668
1669 idmef_file_set_name(file, tmp);
1670 break;
1671 }
1672
1673 case IDMEF_MSG_FILE_PATH: {
1674 prelude_string_t *tmp = NULL;
1675
1676 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1677 if ( ret < 0 )
1678 return ret;
1679
1680 idmef_file_set_path(file, tmp);
1681 break;
1682 }
1683
1684 case IDMEF_MSG_FILE_CREATE_TIME: {
1685 idmef_time_t *tmp = NULL;
1686
1687 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
1688 if ( ret < 0 )
1689 return ret;
1690
1691 idmef_file_set_create_time(file, tmp);
1692 break;
1693 }
1694
1695 case IDMEF_MSG_FILE_MODIFY_TIME: {
1696 idmef_time_t *tmp = NULL;
1697
1698 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
1699 if ( ret < 0 )
1700 return ret;
1701
1702 idmef_file_set_modify_time(file, tmp);
1703 break;
1704 }
1705
1706 case IDMEF_MSG_FILE_ACCESS_TIME: {
1707 idmef_time_t *tmp = NULL;
1708
1709 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
1710 if ( ret < 0 )
1711 return ret;
1712
1713 idmef_file_set_access_time(file, tmp);
1714 break;
1715 }
1716
1717 case IDMEF_MSG_FILE_DATA_SIZE: {
1718 uint64_t tmp = 0;
1719
1720 ret = prelude_extract_uint64_safe(&tmp, buf, len);
1721 if ( ret < 0 )
1722 return ret;
1723
1724 idmef_file_set_data_size(file, tmp);
1725 break;
1726 }
1727
1728 case IDMEF_MSG_FILE_DISK_SIZE: {
1729 uint64_t tmp = 0;
1730
1731 ret = prelude_extract_uint64_safe(&tmp, buf, len);
1732 if ( ret < 0 )
1733 return ret;
1734
1735 idmef_file_set_disk_size(file, tmp);
1736 break;
1737 }
1738
1739 case IDMEF_MSG_FILE_ACCESS_TAG: {
1740 int ret;
1741 idmef_file_access_t *tmp = NULL;
1742
1743 ret = idmef_file_new_file_access(file, &tmp, -1);
1744 if ( ret < 0 )
1745 return ret;
1746
1747
1748
1749 ret = idmef_file_access_read(tmp, msg);
1750 if ( ret < 0 )
1751 return ret;
1752
1753 break;
1754 }
1755
1756 case IDMEF_MSG_LINKAGE_TAG: {
1757 int ret;
1758 idmef_linkage_t *tmp = NULL;
1759
1760 ret = idmef_file_new_linkage(file, &tmp, -1);
1761 if ( ret < 0 )
1762 return ret;
1763
1764
1765
1766 ret = idmef_linkage_read(tmp, msg);
1767 if ( ret < 0 )
1768 return ret;
1769
1770 break;
1771 }
1772
1773 case IDMEF_MSG_INODE_TAG: {
1774 int ret;
1775 idmef_inode_t *tmp = NULL;
1776
1777 ret = idmef_file_new_inode(file, &tmp);
1778 if ( ret < 0 )
1779 return ret;
1780
1781
1782
1783 ret = idmef_inode_read(tmp, msg);
1784 if ( ret < 0 )
1785 return ret;
1786
1787 break;
1788 }
1789
1790 case IDMEF_MSG_CHECKSUM_TAG: {
1791 int ret;
1792 idmef_checksum_t *tmp = NULL;
1793
1794 ret = idmef_file_new_checksum(file, &tmp, -1);
1795 if ( ret < 0 )
1796 return ret;
1797
1798
1799
1800 ret = idmef_checksum_read(tmp, msg);
1801 if ( ret < 0 )
1802 return ret;
1803
1804 break;
1805 }
1806
1807 case IDMEF_MSG_FILE_CATEGORY: {
1808 int32_t tmp = 0;
1809
1810 ret = prelude_extract_int32_safe(&tmp, buf, len);
1811 if ( ret < 0 )
1812 return ret;
1813
1814 idmef_file_set_category(file, tmp);
1815 break;
1816 }
1817
1818 case IDMEF_MSG_FILE_FSTYPE: {
1819 int32_t tmp = 0;
1820
1821 ret = prelude_extract_int32_safe(&tmp, buf, len);
1822 if ( ret < 0 )
1823 return ret;
1824
1825 idmef_file_set_fstype(file, tmp);
1826 break;
1827 }
1828
1829 case IDMEF_MSG_FILE_FILE_TYPE: {
1830 prelude_string_t *tmp = NULL;
1831
1832 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1833 if ( ret < 0 )
1834 return ret;
1835
1836 idmef_file_set_file_type(file, tmp);
1837 break;
1838 }
1839
1840 case IDMEF_MSG_END_OF_TAG:
1841 return 0;
1842
1843 default:
1844 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_file_t: '%u'", tag);
1845 }
1846
1847 }
1848
1849 return 0;
1850 }
1851
1852 /**
1853 * idmef_linkage_read:
1854 * @linkage: Pointer to a #idmef_linkage_t object.
1855 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1856 *
1857 * Read an idmef_linkage from the @msg message, and
1858 * store it into @linkage.
1859 *
1860 * Returns: 0 on success, a negative value if an error occured.
1861 */
idmef_linkage_read(idmef_linkage_t * linkage,prelude_msg_t * msg)1862 int idmef_linkage_read(idmef_linkage_t *linkage, prelude_msg_t *msg)
1863 {
1864 int ret;
1865 void *buf;
1866 uint8_t tag;
1867 uint32_t len;
1868
1869 while ( 1 ) {
1870 ret = prelude_msg_get(msg, &tag, &len, &buf);
1871 if ( ret < 0 )
1872 return ret;
1873
1874 switch ( tag ) {
1875
1876 case IDMEF_MSG_LINKAGE_CATEGORY: {
1877 int32_t tmp = 0;
1878
1879 ret = prelude_extract_int32_safe(&tmp, buf, len);
1880 if ( ret < 0 )
1881 return ret;
1882
1883 idmef_linkage_set_category(linkage, tmp);
1884 break;
1885 }
1886
1887 case IDMEF_MSG_LINKAGE_NAME: {
1888 prelude_string_t *tmp = NULL;
1889
1890 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1891 if ( ret < 0 )
1892 return ret;
1893
1894 idmef_linkage_set_name(linkage, tmp);
1895 break;
1896 }
1897
1898 case IDMEF_MSG_LINKAGE_PATH: {
1899 prelude_string_t *tmp = NULL;
1900
1901 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1902 if ( ret < 0 )
1903 return ret;
1904
1905 idmef_linkage_set_path(linkage, tmp);
1906 break;
1907 }
1908
1909 case IDMEF_MSG_FILE_TAG: {
1910 int ret;
1911 idmef_file_t *tmp = NULL;
1912
1913 ret = idmef_linkage_new_file(linkage, &tmp);
1914 if ( ret < 0 )
1915 return ret;
1916
1917
1918
1919 ret = idmef_file_read(tmp, msg);
1920 if ( ret < 0 )
1921 return ret;
1922
1923 break;
1924 }
1925
1926 case IDMEF_MSG_END_OF_TAG:
1927 return 0;
1928
1929 default:
1930 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_linkage_t: '%u'", tag);
1931 }
1932
1933 }
1934
1935 return 0;
1936 }
1937
1938 /**
1939 * idmef_target_read:
1940 * @target: Pointer to a #idmef_target_t object.
1941 * @msg: Pointer to a #prelude_msg_t object, containing a message.
1942 *
1943 * Read an idmef_target from the @msg message, and
1944 * store it into @target.
1945 *
1946 * Returns: 0 on success, a negative value if an error occured.
1947 */
idmef_target_read(idmef_target_t * target,prelude_msg_t * msg)1948 int idmef_target_read(idmef_target_t *target, prelude_msg_t *msg)
1949 {
1950 int ret;
1951 void *buf;
1952 uint8_t tag;
1953 uint32_t len;
1954
1955 while ( 1 ) {
1956 ret = prelude_msg_get(msg, &tag, &len, &buf);
1957 if ( ret < 0 )
1958 return ret;
1959
1960 switch ( tag ) {
1961
1962 case IDMEF_MSG_TARGET_IDENT: {
1963 prelude_string_t *tmp = NULL;
1964
1965 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1966 if ( ret < 0 )
1967 return ret;
1968
1969 idmef_target_set_ident(target, tmp);
1970 break;
1971 }
1972
1973 case IDMEF_MSG_TARGET_DECOY: {
1974 int32_t tmp = 0;
1975
1976 ret = prelude_extract_int32_safe(&tmp, buf, len);
1977 if ( ret < 0 )
1978 return ret;
1979
1980 idmef_target_set_decoy(target, tmp);
1981 break;
1982 }
1983
1984 case IDMEF_MSG_TARGET_INTERFACE: {
1985 prelude_string_t *tmp = NULL;
1986
1987 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
1988 if ( ret < 0 )
1989 return ret;
1990
1991 idmef_target_set_interface(target, tmp);
1992 break;
1993 }
1994
1995 case IDMEF_MSG_NODE_TAG: {
1996 int ret;
1997 idmef_node_t *tmp = NULL;
1998
1999 ret = idmef_target_new_node(target, &tmp);
2000 if ( ret < 0 )
2001 return ret;
2002
2003
2004
2005 ret = idmef_node_read(tmp, msg);
2006 if ( ret < 0 )
2007 return ret;
2008
2009 break;
2010 }
2011
2012 case IDMEF_MSG_USER_TAG: {
2013 int ret;
2014 idmef_user_t *tmp = NULL;
2015
2016 ret = idmef_target_new_user(target, &tmp);
2017 if ( ret < 0 )
2018 return ret;
2019
2020
2021
2022 ret = idmef_user_read(tmp, msg);
2023 if ( ret < 0 )
2024 return ret;
2025
2026 break;
2027 }
2028
2029 case IDMEF_MSG_PROCESS_TAG: {
2030 int ret;
2031 idmef_process_t *tmp = NULL;
2032
2033 ret = idmef_target_new_process(target, &tmp);
2034 if ( ret < 0 )
2035 return ret;
2036
2037
2038
2039 ret = idmef_process_read(tmp, msg);
2040 if ( ret < 0 )
2041 return ret;
2042
2043 break;
2044 }
2045
2046 case IDMEF_MSG_SERVICE_TAG: {
2047 int ret;
2048 idmef_service_t *tmp = NULL;
2049
2050 ret = idmef_target_new_service(target, &tmp);
2051 if ( ret < 0 )
2052 return ret;
2053
2054
2055
2056 ret = idmef_service_read(tmp, msg);
2057 if ( ret < 0 )
2058 return ret;
2059
2060 break;
2061 }
2062
2063 case IDMEF_MSG_FILE_TAG: {
2064 int ret;
2065 idmef_file_t *tmp = NULL;
2066
2067 ret = idmef_target_new_file(target, &tmp, -1);
2068 if ( ret < 0 )
2069 return ret;
2070
2071
2072
2073 ret = idmef_file_read(tmp, msg);
2074 if ( ret < 0 )
2075 return ret;
2076
2077 break;
2078 }
2079
2080 case IDMEF_MSG_END_OF_TAG:
2081 return 0;
2082
2083 default:
2084 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_target_t: '%u'", tag);
2085 }
2086
2087 }
2088
2089 return 0;
2090 }
2091
2092 /**
2093 * idmef_analyzer_read:
2094 * @analyzer: Pointer to a #idmef_analyzer_t object.
2095 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2096 *
2097 * Read an idmef_analyzer from the @msg message, and
2098 * store it into @analyzer.
2099 *
2100 * Returns: 0 on success, a negative value if an error occured.
2101 */
idmef_analyzer_read(idmef_analyzer_t * analyzer,prelude_msg_t * msg)2102 int idmef_analyzer_read(idmef_analyzer_t *analyzer, prelude_msg_t *msg)
2103 {
2104 int ret;
2105 void *buf;
2106 uint8_t tag;
2107 uint32_t len;
2108
2109 while ( 1 ) {
2110 ret = prelude_msg_get(msg, &tag, &len, &buf);
2111 if ( ret < 0 )
2112 return ret;
2113
2114 switch ( tag ) {
2115
2116 case IDMEF_MSG_ANALYZER_ANALYZERID: {
2117 prelude_string_t *tmp = NULL;
2118
2119 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2120 if ( ret < 0 )
2121 return ret;
2122
2123 idmef_analyzer_set_analyzerid(analyzer, tmp);
2124 break;
2125 }
2126
2127 case IDMEF_MSG_ANALYZER_NAME: {
2128 prelude_string_t *tmp = NULL;
2129
2130 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2131 if ( ret < 0 )
2132 return ret;
2133
2134 idmef_analyzer_set_name(analyzer, tmp);
2135 break;
2136 }
2137
2138 case IDMEF_MSG_ANALYZER_MANUFACTURER: {
2139 prelude_string_t *tmp = NULL;
2140
2141 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2142 if ( ret < 0 )
2143 return ret;
2144
2145 idmef_analyzer_set_manufacturer(analyzer, tmp);
2146 break;
2147 }
2148
2149 case IDMEF_MSG_ANALYZER_MODEL: {
2150 prelude_string_t *tmp = NULL;
2151
2152 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2153 if ( ret < 0 )
2154 return ret;
2155
2156 idmef_analyzer_set_model(analyzer, tmp);
2157 break;
2158 }
2159
2160 case IDMEF_MSG_ANALYZER_VERSION: {
2161 prelude_string_t *tmp = NULL;
2162
2163 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2164 if ( ret < 0 )
2165 return ret;
2166
2167 idmef_analyzer_set_version(analyzer, tmp);
2168 break;
2169 }
2170
2171 case IDMEF_MSG_ANALYZER_CLASS: {
2172 prelude_string_t *tmp = NULL;
2173
2174 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2175 if ( ret < 0 )
2176 return ret;
2177
2178 idmef_analyzer_set_class(analyzer, tmp);
2179 break;
2180 }
2181
2182 case IDMEF_MSG_ANALYZER_OSTYPE: {
2183 prelude_string_t *tmp = NULL;
2184
2185 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2186 if ( ret < 0 )
2187 return ret;
2188
2189 idmef_analyzer_set_ostype(analyzer, tmp);
2190 break;
2191 }
2192
2193 case IDMEF_MSG_ANALYZER_OSVERSION: {
2194 prelude_string_t *tmp = NULL;
2195
2196 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2197 if ( ret < 0 )
2198 return ret;
2199
2200 idmef_analyzer_set_osversion(analyzer, tmp);
2201 break;
2202 }
2203
2204 case IDMEF_MSG_NODE_TAG: {
2205 int ret;
2206 idmef_node_t *tmp = NULL;
2207
2208 ret = idmef_analyzer_new_node(analyzer, &tmp);
2209 if ( ret < 0 )
2210 return ret;
2211
2212
2213
2214 ret = idmef_node_read(tmp, msg);
2215 if ( ret < 0 )
2216 return ret;
2217
2218 break;
2219 }
2220
2221 case IDMEF_MSG_PROCESS_TAG: {
2222 int ret;
2223 idmef_process_t *tmp = NULL;
2224
2225 ret = idmef_analyzer_new_process(analyzer, &tmp);
2226 if ( ret < 0 )
2227 return ret;
2228
2229
2230
2231 ret = idmef_process_read(tmp, msg);
2232 if ( ret < 0 )
2233 return ret;
2234
2235 break;
2236 }
2237
2238 case IDMEF_MSG_END_OF_TAG:
2239 return 0;
2240
2241 default:
2242 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_analyzer_t: '%u'", tag);
2243 }
2244
2245 }
2246
2247 return 0;
2248 }
2249
2250 /**
2251 * idmef_alertident_read:
2252 * @alertident: Pointer to a #idmef_alertident_t object.
2253 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2254 *
2255 * Read an idmef_alertident from the @msg message, and
2256 * store it into @alertident.
2257 *
2258 * Returns: 0 on success, a negative value if an error occured.
2259 */
idmef_alertident_read(idmef_alertident_t * alertident,prelude_msg_t * msg)2260 int idmef_alertident_read(idmef_alertident_t *alertident, prelude_msg_t *msg)
2261 {
2262 int ret;
2263 void *buf;
2264 uint8_t tag;
2265 uint32_t len;
2266
2267 while ( 1 ) {
2268 ret = prelude_msg_get(msg, &tag, &len, &buf);
2269 if ( ret < 0 )
2270 return ret;
2271
2272 switch ( tag ) {
2273
2274 case IDMEF_MSG_ALERTIDENT_ALERTIDENT: {
2275 prelude_string_t *tmp = NULL;
2276
2277 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2278 if ( ret < 0 )
2279 return ret;
2280
2281 idmef_alertident_set_alertident(alertident, tmp);
2282 break;
2283 }
2284
2285 case IDMEF_MSG_ALERTIDENT_ANALYZERID: {
2286 prelude_string_t *tmp = NULL;
2287
2288 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2289 if ( ret < 0 )
2290 return ret;
2291
2292 idmef_alertident_set_analyzerid(alertident, tmp);
2293 break;
2294 }
2295
2296 case IDMEF_MSG_END_OF_TAG:
2297 return 0;
2298
2299 default:
2300 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_alertident_t: '%u'", tag);
2301 }
2302
2303 }
2304
2305 return 0;
2306 }
2307
2308 /**
2309 * idmef_impact_read:
2310 * @impact: Pointer to a #idmef_impact_t object.
2311 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2312 *
2313 * Read an idmef_impact from the @msg message, and
2314 * store it into @impact.
2315 *
2316 * Returns: 0 on success, a negative value if an error occured.
2317 */
idmef_impact_read(idmef_impact_t * impact,prelude_msg_t * msg)2318 int idmef_impact_read(idmef_impact_t *impact, prelude_msg_t *msg)
2319 {
2320 int ret;
2321 void *buf;
2322 uint8_t tag;
2323 uint32_t len;
2324
2325 while ( 1 ) {
2326 ret = prelude_msg_get(msg, &tag, &len, &buf);
2327 if ( ret < 0 )
2328 return ret;
2329
2330 switch ( tag ) {
2331
2332 case IDMEF_MSG_IMPACT_SEVERITY: {
2333 int32_t tmp = 0;
2334
2335 ret = prelude_extract_int32_safe(&tmp, buf, len);
2336 if ( ret < 0 )
2337 return ret;
2338
2339 idmef_impact_set_severity(impact, tmp);
2340 break;
2341 }
2342
2343 case IDMEF_MSG_IMPACT_COMPLETION: {
2344 int32_t tmp = 0;
2345
2346 ret = prelude_extract_int32_safe(&tmp, buf, len);
2347 if ( ret < 0 )
2348 return ret;
2349
2350 idmef_impact_set_completion(impact, tmp);
2351 break;
2352 }
2353
2354 case IDMEF_MSG_IMPACT_TYPE: {
2355 int32_t tmp = 0;
2356
2357 ret = prelude_extract_int32_safe(&tmp, buf, len);
2358 if ( ret < 0 )
2359 return ret;
2360
2361 idmef_impact_set_type(impact, tmp);
2362 break;
2363 }
2364
2365 case IDMEF_MSG_IMPACT_DESCRIPTION: {
2366 prelude_string_t *tmp = NULL;
2367
2368 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2369 if ( ret < 0 )
2370 return ret;
2371
2372 idmef_impact_set_description(impact, tmp);
2373 break;
2374 }
2375
2376 case IDMEF_MSG_END_OF_TAG:
2377 return 0;
2378
2379 default:
2380 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_impact_t: '%u'", tag);
2381 }
2382
2383 }
2384
2385 return 0;
2386 }
2387
2388 /**
2389 * idmef_action_read:
2390 * @action: Pointer to a #idmef_action_t object.
2391 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2392 *
2393 * Read an idmef_action from the @msg message, and
2394 * store it into @action.
2395 *
2396 * Returns: 0 on success, a negative value if an error occured.
2397 */
idmef_action_read(idmef_action_t * action,prelude_msg_t * msg)2398 int idmef_action_read(idmef_action_t *action, prelude_msg_t *msg)
2399 {
2400 int ret;
2401 void *buf;
2402 uint8_t tag;
2403 uint32_t len;
2404
2405 while ( 1 ) {
2406 ret = prelude_msg_get(msg, &tag, &len, &buf);
2407 if ( ret < 0 )
2408 return ret;
2409
2410 switch ( tag ) {
2411
2412 case IDMEF_MSG_ACTION_CATEGORY: {
2413 int32_t tmp = 0;
2414
2415 ret = prelude_extract_int32_safe(&tmp, buf, len);
2416 if ( ret < 0 )
2417 return ret;
2418
2419 idmef_action_set_category(action, tmp);
2420 break;
2421 }
2422
2423 case IDMEF_MSG_ACTION_DESCRIPTION: {
2424 prelude_string_t *tmp = NULL;
2425
2426 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2427 if ( ret < 0 )
2428 return ret;
2429
2430 idmef_action_set_description(action, tmp);
2431 break;
2432 }
2433
2434 case IDMEF_MSG_END_OF_TAG:
2435 return 0;
2436
2437 default:
2438 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_action_t: '%u'", tag);
2439 }
2440
2441 }
2442
2443 return 0;
2444 }
2445
2446 /**
2447 * idmef_confidence_read:
2448 * @confidence: Pointer to a #idmef_confidence_t object.
2449 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2450 *
2451 * Read an idmef_confidence from the @msg message, and
2452 * store it into @confidence.
2453 *
2454 * Returns: 0 on success, a negative value if an error occured.
2455 */
idmef_confidence_read(idmef_confidence_t * confidence,prelude_msg_t * msg)2456 int idmef_confidence_read(idmef_confidence_t *confidence, prelude_msg_t *msg)
2457 {
2458 int ret;
2459 void *buf;
2460 uint8_t tag;
2461 uint32_t len;
2462
2463 while ( 1 ) {
2464 ret = prelude_msg_get(msg, &tag, &len, &buf);
2465 if ( ret < 0 )
2466 return ret;
2467
2468 switch ( tag ) {
2469
2470 case IDMEF_MSG_CONFIDENCE_RATING: {
2471 int32_t tmp = 0;
2472
2473 ret = prelude_extract_int32_safe(&tmp, buf, len);
2474 if ( ret < 0 )
2475 return ret;
2476
2477 idmef_confidence_set_rating(confidence, tmp);
2478 break;
2479 }
2480
2481 case IDMEF_MSG_CONFIDENCE_CONFIDENCE: {
2482 float tmp = 0;
2483
2484 ret = prelude_extract_float_safe(&tmp, buf, len);
2485 if ( ret < 0 )
2486 return ret;
2487
2488 idmef_confidence_set_confidence(confidence, tmp);
2489 break;
2490 }
2491
2492 case IDMEF_MSG_END_OF_TAG:
2493 return 0;
2494
2495 default:
2496 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_confidence_t: '%u'", tag);
2497 }
2498
2499 }
2500
2501 return 0;
2502 }
2503
2504 /**
2505 * idmef_assessment_read:
2506 * @assessment: Pointer to a #idmef_assessment_t object.
2507 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2508 *
2509 * Read an idmef_assessment from the @msg message, and
2510 * store it into @assessment.
2511 *
2512 * Returns: 0 on success, a negative value if an error occured.
2513 */
idmef_assessment_read(idmef_assessment_t * assessment,prelude_msg_t * msg)2514 int idmef_assessment_read(idmef_assessment_t *assessment, prelude_msg_t *msg)
2515 {
2516 int ret;
2517 void *buf;
2518 uint8_t tag;
2519 uint32_t len;
2520
2521 while ( 1 ) {
2522 ret = prelude_msg_get(msg, &tag, &len, &buf);
2523 if ( ret < 0 )
2524 return ret;
2525
2526 switch ( tag ) {
2527
2528 case IDMEF_MSG_IMPACT_TAG: {
2529 int ret;
2530 idmef_impact_t *tmp = NULL;
2531
2532 ret = idmef_assessment_new_impact(assessment, &tmp);
2533 if ( ret < 0 )
2534 return ret;
2535
2536
2537
2538 ret = idmef_impact_read(tmp, msg);
2539 if ( ret < 0 )
2540 return ret;
2541
2542 break;
2543 }
2544
2545 case IDMEF_MSG_ACTION_TAG: {
2546 int ret;
2547 idmef_action_t *tmp = NULL;
2548
2549 ret = idmef_assessment_new_action(assessment, &tmp, -1);
2550 if ( ret < 0 )
2551 return ret;
2552
2553
2554
2555 ret = idmef_action_read(tmp, msg);
2556 if ( ret < 0 )
2557 return ret;
2558
2559 break;
2560 }
2561
2562 case IDMEF_MSG_CONFIDENCE_TAG: {
2563 int ret;
2564 idmef_confidence_t *tmp = NULL;
2565
2566 ret = idmef_assessment_new_confidence(assessment, &tmp);
2567 if ( ret < 0 )
2568 return ret;
2569
2570
2571
2572 ret = idmef_confidence_read(tmp, msg);
2573 if ( ret < 0 )
2574 return ret;
2575
2576 break;
2577 }
2578
2579 case IDMEF_MSG_END_OF_TAG:
2580 return 0;
2581
2582 default:
2583 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_assessment_t: '%u'", tag);
2584 }
2585
2586 }
2587
2588 return 0;
2589 }
2590
2591 /**
2592 * idmef_tool_alert_read:
2593 * @tool_alert: Pointer to a #idmef_tool_alert_t object.
2594 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2595 *
2596 * Read an idmef_tool_alert from the @msg message, and
2597 * store it into @tool_alert.
2598 *
2599 * Returns: 0 on success, a negative value if an error occured.
2600 */
idmef_tool_alert_read(idmef_tool_alert_t * tool_alert,prelude_msg_t * msg)2601 int idmef_tool_alert_read(idmef_tool_alert_t *tool_alert, prelude_msg_t *msg)
2602 {
2603 int ret;
2604 void *buf;
2605 uint8_t tag;
2606 uint32_t len;
2607
2608 while ( 1 ) {
2609 ret = prelude_msg_get(msg, &tag, &len, &buf);
2610 if ( ret < 0 )
2611 return ret;
2612
2613 switch ( tag ) {
2614
2615 case IDMEF_MSG_TOOL_ALERT_NAME: {
2616 prelude_string_t *tmp = NULL;
2617
2618 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2619 if ( ret < 0 )
2620 return ret;
2621
2622 idmef_tool_alert_set_name(tool_alert, tmp);
2623 break;
2624 }
2625
2626 case IDMEF_MSG_TOOL_ALERT_COMMAND: {
2627 prelude_string_t *tmp = NULL;
2628
2629 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2630 if ( ret < 0 )
2631 return ret;
2632
2633 idmef_tool_alert_set_command(tool_alert, tmp);
2634 break;
2635 }
2636
2637 case IDMEF_MSG_ALERTIDENT_TAG: {
2638 int ret;
2639 idmef_alertident_t *tmp = NULL;
2640
2641 ret = idmef_tool_alert_new_alertident(tool_alert, &tmp, -1);
2642 if ( ret < 0 )
2643 return ret;
2644
2645
2646
2647 ret = idmef_alertident_read(tmp, msg);
2648 if ( ret < 0 )
2649 return ret;
2650
2651 break;
2652 }
2653
2654 case IDMEF_MSG_END_OF_TAG:
2655 return 0;
2656
2657 default:
2658 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_tool_alert_t: '%u'", tag);
2659 }
2660
2661 }
2662
2663 return 0;
2664 }
2665
2666 /**
2667 * idmef_correlation_alert_read:
2668 * @correlation_alert: Pointer to a #idmef_correlation_alert_t object.
2669 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2670 *
2671 * Read an idmef_correlation_alert from the @msg message, and
2672 * store it into @correlation_alert.
2673 *
2674 * Returns: 0 on success, a negative value if an error occured.
2675 */
idmef_correlation_alert_read(idmef_correlation_alert_t * correlation_alert,prelude_msg_t * msg)2676 int idmef_correlation_alert_read(idmef_correlation_alert_t *correlation_alert, prelude_msg_t *msg)
2677 {
2678 int ret;
2679 void *buf;
2680 uint8_t tag;
2681 uint32_t len;
2682
2683 while ( 1 ) {
2684 ret = prelude_msg_get(msg, &tag, &len, &buf);
2685 if ( ret < 0 )
2686 return ret;
2687
2688 switch ( tag ) {
2689
2690 case IDMEF_MSG_CORRELATION_ALERT_NAME: {
2691 prelude_string_t *tmp = NULL;
2692
2693 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2694 if ( ret < 0 )
2695 return ret;
2696
2697 idmef_correlation_alert_set_name(correlation_alert, tmp);
2698 break;
2699 }
2700
2701 case IDMEF_MSG_ALERTIDENT_TAG: {
2702 int ret;
2703 idmef_alertident_t *tmp = NULL;
2704
2705 ret = idmef_correlation_alert_new_alertident(correlation_alert, &tmp, -1);
2706 if ( ret < 0 )
2707 return ret;
2708
2709
2710
2711 ret = idmef_alertident_read(tmp, msg);
2712 if ( ret < 0 )
2713 return ret;
2714
2715 break;
2716 }
2717
2718 case IDMEF_MSG_END_OF_TAG:
2719 return 0;
2720
2721 default:
2722 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_correlation_alert_t: '%u'", tag);
2723 }
2724
2725 }
2726
2727 return 0;
2728 }
2729
2730 /**
2731 * idmef_overflow_alert_read:
2732 * @overflow_alert: Pointer to a #idmef_overflow_alert_t object.
2733 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2734 *
2735 * Read an idmef_overflow_alert from the @msg message, and
2736 * store it into @overflow_alert.
2737 *
2738 * Returns: 0 on success, a negative value if an error occured.
2739 */
idmef_overflow_alert_read(idmef_overflow_alert_t * overflow_alert,prelude_msg_t * msg)2740 int idmef_overflow_alert_read(idmef_overflow_alert_t *overflow_alert, prelude_msg_t *msg)
2741 {
2742 int ret;
2743 void *buf;
2744 uint8_t tag;
2745 uint32_t len;
2746
2747 while ( 1 ) {
2748 ret = prelude_msg_get(msg, &tag, &len, &buf);
2749 if ( ret < 0 )
2750 return ret;
2751
2752 switch ( tag ) {
2753
2754 case IDMEF_MSG_OVERFLOW_ALERT_PROGRAM: {
2755 prelude_string_t *tmp = NULL;
2756
2757 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2758 if ( ret < 0 )
2759 return ret;
2760
2761 idmef_overflow_alert_set_program(overflow_alert, tmp);
2762 break;
2763 }
2764
2765 case IDMEF_MSG_OVERFLOW_ALERT_SIZE: {
2766 uint32_t tmp = 0;
2767
2768 ret = prelude_extract_uint32_safe(&tmp, buf, len);
2769 if ( ret < 0 )
2770 return ret;
2771
2772 idmef_overflow_alert_set_size(overflow_alert, tmp);
2773 break;
2774 }
2775
2776 case IDMEF_MSG_OVERFLOW_ALERT_BUFFER: {
2777 idmef_data_t *tmp = NULL;
2778
2779 ret = prelude_extract_data_safe(&tmp, buf, len, msg);
2780 if ( ret < 0 )
2781 return ret;
2782
2783 idmef_overflow_alert_set_buffer(overflow_alert, tmp);
2784 break;
2785 }
2786
2787 case IDMEF_MSG_END_OF_TAG:
2788 return 0;
2789
2790 default:
2791 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_overflow_alert_t: '%u'", tag);
2792 }
2793
2794 }
2795
2796 return 0;
2797 }
2798
2799 /**
2800 * idmef_alert_read:
2801 * @alert: Pointer to a #idmef_alert_t object.
2802 * @msg: Pointer to a #prelude_msg_t object, containing a message.
2803 *
2804 * Read an idmef_alert from the @msg message, and
2805 * store it into @alert.
2806 *
2807 * Returns: 0 on success, a negative value if an error occured.
2808 */
idmef_alert_read(idmef_alert_t * alert,prelude_msg_t * msg)2809 int idmef_alert_read(idmef_alert_t *alert, prelude_msg_t *msg)
2810 {
2811 int ret;
2812 void *buf;
2813 uint8_t tag;
2814 uint32_t len;
2815
2816 while ( 1 ) {
2817 ret = prelude_msg_get(msg, &tag, &len, &buf);
2818 if ( ret < 0 )
2819 return ret;
2820
2821 switch ( tag ) {
2822
2823 case IDMEF_MSG_ALERT_MESSAGEID: {
2824 prelude_string_t *tmp = NULL;
2825
2826 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
2827 if ( ret < 0 )
2828 return ret;
2829
2830 idmef_alert_set_messageid(alert, tmp);
2831 break;
2832 }
2833
2834 case IDMEF_MSG_ANALYZER_TAG: {
2835 int ret;
2836 idmef_analyzer_t *tmp = NULL;
2837
2838 ret = idmef_alert_new_analyzer(alert, &tmp, -1);
2839 if ( ret < 0 )
2840 return ret;
2841
2842
2843
2844 ret = idmef_analyzer_read(tmp, msg);
2845 if ( ret < 0 )
2846 return ret;
2847
2848 break;
2849 }
2850
2851 case IDMEF_MSG_ALERT_CREATE_TIME: {
2852 idmef_time_t *tmp = NULL;
2853
2854 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
2855 if ( ret < 0 )
2856 return ret;
2857
2858 idmef_alert_set_create_time(alert, tmp);
2859 break;
2860 }
2861
2862 case IDMEF_MSG_CLASSIFICATION_TAG: {
2863 int ret;
2864 idmef_classification_t *tmp = NULL;
2865
2866 ret = idmef_alert_new_classification(alert, &tmp);
2867 if ( ret < 0 )
2868 return ret;
2869
2870
2871
2872 ret = idmef_classification_read(tmp, msg);
2873 if ( ret < 0 )
2874 return ret;
2875
2876 break;
2877 }
2878
2879 case IDMEF_MSG_ALERT_DETECT_TIME: {
2880 idmef_time_t *tmp = NULL;
2881
2882 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
2883 if ( ret < 0 )
2884 return ret;
2885
2886 idmef_alert_set_detect_time(alert, tmp);
2887 break;
2888 }
2889
2890 case IDMEF_MSG_ALERT_ANALYZER_TIME: {
2891 idmef_time_t *tmp = NULL;
2892
2893 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
2894 if ( ret < 0 )
2895 return ret;
2896
2897 idmef_alert_set_analyzer_time(alert, tmp);
2898 break;
2899 }
2900
2901 case IDMEF_MSG_SOURCE_TAG: {
2902 int ret;
2903 idmef_source_t *tmp = NULL;
2904
2905 ret = idmef_alert_new_source(alert, &tmp, -1);
2906 if ( ret < 0 )
2907 return ret;
2908
2909
2910
2911 ret = idmef_source_read(tmp, msg);
2912 if ( ret < 0 )
2913 return ret;
2914
2915 break;
2916 }
2917
2918 case IDMEF_MSG_TARGET_TAG: {
2919 int ret;
2920 idmef_target_t *tmp = NULL;
2921
2922 ret = idmef_alert_new_target(alert, &tmp, -1);
2923 if ( ret < 0 )
2924 return ret;
2925
2926
2927
2928 ret = idmef_target_read(tmp, msg);
2929 if ( ret < 0 )
2930 return ret;
2931
2932 break;
2933 }
2934
2935 case IDMEF_MSG_ASSESSMENT_TAG: {
2936 int ret;
2937 idmef_assessment_t *tmp = NULL;
2938
2939 ret = idmef_alert_new_assessment(alert, &tmp);
2940 if ( ret < 0 )
2941 return ret;
2942
2943
2944
2945 ret = idmef_assessment_read(tmp, msg);
2946 if ( ret < 0 )
2947 return ret;
2948
2949 break;
2950 }
2951
2952 case IDMEF_MSG_ADDITIONAL_DATA_TAG: {
2953 int ret;
2954 idmef_additional_data_t *tmp = NULL;
2955
2956 ret = idmef_alert_new_additional_data(alert, &tmp, -1);
2957 if ( ret < 0 )
2958 return ret;
2959
2960
2961
2962 ret = idmef_additional_data_read(tmp, msg);
2963 if ( ret < 0 )
2964 return ret;
2965
2966 break;
2967 }
2968
2969 case IDMEF_MSG_TOOL_ALERT_TAG: {
2970 int ret;
2971 idmef_tool_alert_t *tmp = NULL;
2972
2973 ret = idmef_alert_new_tool_alert(alert, &tmp);
2974 if ( ret < 0 )
2975 return ret;
2976
2977
2978
2979 ret = idmef_tool_alert_read(tmp, msg);
2980 if ( ret < 0 )
2981 return ret;
2982
2983 break;
2984 }
2985
2986 case IDMEF_MSG_CORRELATION_ALERT_TAG: {
2987 int ret;
2988 idmef_correlation_alert_t *tmp = NULL;
2989
2990 ret = idmef_alert_new_correlation_alert(alert, &tmp);
2991 if ( ret < 0 )
2992 return ret;
2993
2994
2995
2996 ret = idmef_correlation_alert_read(tmp, msg);
2997 if ( ret < 0 )
2998 return ret;
2999
3000 break;
3001 }
3002
3003 case IDMEF_MSG_OVERFLOW_ALERT_TAG: {
3004 int ret;
3005 idmef_overflow_alert_t *tmp = NULL;
3006
3007 ret = idmef_alert_new_overflow_alert(alert, &tmp);
3008 if ( ret < 0 )
3009 return ret;
3010
3011
3012
3013 ret = idmef_overflow_alert_read(tmp, msg);
3014 if ( ret < 0 )
3015 return ret;
3016
3017 break;
3018 }
3019
3020 case IDMEF_MSG_END_OF_TAG:
3021 return 0;
3022
3023 default:
3024 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_alert_t: '%u'", tag);
3025 }
3026
3027 }
3028
3029 return 0;
3030 }
3031
3032 /**
3033 * idmef_heartbeat_read:
3034 * @heartbeat: Pointer to a #idmef_heartbeat_t object.
3035 * @msg: Pointer to a #prelude_msg_t object, containing a message.
3036 *
3037 * Read an idmef_heartbeat from the @msg message, and
3038 * store it into @heartbeat.
3039 *
3040 * Returns: 0 on success, a negative value if an error occured.
3041 */
idmef_heartbeat_read(idmef_heartbeat_t * heartbeat,prelude_msg_t * msg)3042 int idmef_heartbeat_read(idmef_heartbeat_t *heartbeat, prelude_msg_t *msg)
3043 {
3044 int ret;
3045 void *buf;
3046 uint8_t tag;
3047 uint32_t len;
3048
3049 while ( 1 ) {
3050 ret = prelude_msg_get(msg, &tag, &len, &buf);
3051 if ( ret < 0 )
3052 return ret;
3053
3054 switch ( tag ) {
3055
3056 case IDMEF_MSG_HEARTBEAT_MESSAGEID: {
3057 prelude_string_t *tmp = NULL;
3058
3059 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
3060 if ( ret < 0 )
3061 return ret;
3062
3063 idmef_heartbeat_set_messageid(heartbeat, tmp);
3064 break;
3065 }
3066
3067 case IDMEF_MSG_ANALYZER_TAG: {
3068 int ret;
3069 idmef_analyzer_t *tmp = NULL;
3070
3071 ret = idmef_heartbeat_new_analyzer(heartbeat, &tmp, -1);
3072 if ( ret < 0 )
3073 return ret;
3074
3075
3076
3077 ret = idmef_analyzer_read(tmp, msg);
3078 if ( ret < 0 )
3079 return ret;
3080
3081 break;
3082 }
3083
3084 case IDMEF_MSG_HEARTBEAT_CREATE_TIME: {
3085 idmef_time_t *tmp = NULL;
3086
3087 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
3088 if ( ret < 0 )
3089 return ret;
3090
3091 idmef_heartbeat_set_create_time(heartbeat, tmp);
3092 break;
3093 }
3094
3095 case IDMEF_MSG_HEARTBEAT_ANALYZER_TIME: {
3096 idmef_time_t *tmp = NULL;
3097
3098 ret = prelude_extract_time_safe(&tmp, buf, len, msg);
3099 if ( ret < 0 )
3100 return ret;
3101
3102 idmef_heartbeat_set_analyzer_time(heartbeat, tmp);
3103 break;
3104 }
3105
3106 case IDMEF_MSG_HEARTBEAT_HEARTBEAT_INTERVAL: {
3107 uint32_t tmp = 0;
3108
3109 ret = prelude_extract_uint32_safe(&tmp, buf, len);
3110 if ( ret < 0 )
3111 return ret;
3112
3113 idmef_heartbeat_set_heartbeat_interval(heartbeat, tmp);
3114 break;
3115 }
3116
3117 case IDMEF_MSG_ADDITIONAL_DATA_TAG: {
3118 int ret;
3119 idmef_additional_data_t *tmp = NULL;
3120
3121 ret = idmef_heartbeat_new_additional_data(heartbeat, &tmp, -1);
3122 if ( ret < 0 )
3123 return ret;
3124
3125
3126
3127 ret = idmef_additional_data_read(tmp, msg);
3128 if ( ret < 0 )
3129 return ret;
3130
3131 break;
3132 }
3133
3134 case IDMEF_MSG_END_OF_TAG:
3135 return 0;
3136
3137 default:
3138 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_heartbeat_t: '%u'", tag);
3139 }
3140
3141 }
3142
3143 return 0;
3144 }
3145
3146 /**
3147 * idmef_message_read:
3148 * @message: Pointer to a #idmef_message_t object.
3149 * @msg: Pointer to a #prelude_msg_t object, containing a message.
3150 *
3151 * Read an idmef_message from the @msg message, and
3152 * store it into @message.
3153 *
3154 * Returns: 0 on success, a negative value if an error occured.
3155 */
idmef_message_read(idmef_message_t * message,prelude_msg_t * msg)3156 int idmef_message_read(idmef_message_t *message, prelude_msg_t *msg)
3157 {
3158 int ret;
3159 void *buf;
3160 uint8_t tag;
3161 uint32_t len;
3162
3163 while ( 1 ) {
3164 ret = prelude_msg_get(msg, &tag, &len, &buf);
3165 if ( ret < 0 )
3166 return ret;
3167
3168 switch ( tag ) {
3169
3170 case IDMEF_MSG_MESSAGE_VERSION: {
3171 prelude_string_t *tmp = NULL;
3172
3173 ret = prelude_extract_string_safe(&tmp, buf, len, msg);
3174 if ( ret < 0 )
3175 return ret;
3176
3177 idmef_message_set_version(message, tmp);
3178 break;
3179 }
3180
3181 case IDMEF_MSG_ALERT_TAG: {
3182 int ret;
3183 idmef_alert_t *tmp = NULL;
3184
3185 ret = idmef_message_new_alert(message, &tmp);
3186 if ( ret < 0 )
3187 return ret;
3188
3189
3190
3191 ret = idmef_alert_read(tmp, msg);
3192 if ( ret < 0 )
3193 return ret;
3194
3195 break;
3196 }
3197
3198 case IDMEF_MSG_HEARTBEAT_TAG: {
3199 int ret;
3200 idmef_heartbeat_t *tmp = NULL;
3201
3202 ret = idmef_message_new_heartbeat(message, &tmp);
3203 if ( ret < 0 )
3204 return ret;
3205
3206
3207
3208 ret = idmef_heartbeat_read(tmp, msg);
3209 if ( ret < 0 )
3210 return ret;
3211
3212 break;
3213 }
3214
3215 case IDMEF_MSG_END_OF_TAG:
3216 return 0;
3217
3218 default:
3219 return prelude_error_verbose(PRELUDE_ERROR_IDMEF_UNKNOWN_TAG, "Unknown tag while reading idmef_message_t: '%u'", tag);
3220 }
3221
3222 }
3223
3224 return 0;
3225 }
3226