[prev in list] [next in list] [prev in thread] [next in thread]
List: prelude-cvslog
Subject: [prelude-cvslog] r3500 - in trunk/libprelude/src: . include
From: noreply () prelude-ids ! org
Date: 2004-03-09 21:10:04
Message-ID: 20040309211004.AA74265C66 () mail ! prelude-ids ! org
[Download RAW message or body]
Author: yoann
Date: 2004-03-09 22:10:04 +0100 (Tue, 09 Mar 2004)
New Revision: 3500
Added:
trunk/libprelude/src/idmef-message-read.c
trunk/libprelude/src/idmef-message-write.c
trunk/libprelude/src/include/idmef-message-read.h
trunk/libprelude/src/include/idmef-message-write.h
Modified:
trunk/libprelude/src/idmef-tree-print.c
trunk/libprelude/src/idmef-tree-to-string.c
trunk/libprelude/src/include/idmef-message-id.h
trunk/libprelude/src/include/idmef-tree-print.h
trunk/libprelude/src/include/idmef-tree-to-string.h
Log:
commit missing
Added: trunk/libprelude/src/idmef-message-read.c
===================================================================
--- trunk/libprelude/src/idmef-message-read.c 2004-03-06 20:46:32 UTC (rev 3499)
+++ trunk/libprelude/src/idmef-message-read.c 2004-03-09 21:10:04 UTC (rev 3500)
@@ -0,0 +1,2316 @@
+
+/* Auto-generated by the GenerateIDMEFMessageReadC package (Tue Mar 9 21:16:00 \
2004) */ +
+#include <stdio.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "list.h"
+#include "prelude-log.h"
+#include "extract.h"
+#include "prelude-io.h"
+#include "prelude-message.h"
+#include "prelude-message-buffered.h"
+#include "idmef-message-id.h"
+#include "idmef.h"
+#include "idmef-tree-wrap.h"
+
+#include "idmef-message-read.h"
+#include "idmef-util.h"
+
+
+static inline int extract_string_safe(idmef_string_t **out, char *buf, size_t len)
+{
+ if ( buf[len - 1] ) {
+ log(LOG_ERR, "Datatype error: buffer is not a string.\n");
+ return -1;
+ }
+
+ *out = idmef_string_new_ref_fast(buf, len);
+ if ( ! *out ) {
+ log(LOG_ERR, "out of memory\n");
+ return -2;
+ }
+
+ return 0;
+}
+
+
+static inline int extract_time_safe(idmef_time_t **out, void *buf, size_t len)
+{
+ if ( len != sizeof(**out) ) {
+ log(LOG_ERR, "Datatype error: buffer is not a idmef time.\n");
+ return -1;
+ }
+
+ *out = idmef_time_new();
+ if ( ! *out ) {
+ log(LOG_ERR, "out of memory\n");
+ return -2;
+ }
+
+ idmef_time_set_sec(*out, ntohl(((uint32_t *) buf)[0]));
+ idmef_time_set_usec(*out, ntohl(((uint32_t *) buf)[1]));
+
+ return 0;
+}
+
+
+static inline int extract_data_safe(idmef_data_t **out, void *buf, size_t len)
+{
+ *out = idmef_data_new_ref(buf, len);
+ if ( ! *out ) {
+ log(LOG_ERR, "out of memory\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+idmef_additional_data_t *idmef_read_additional_data(prelude_msg_t *msg, \
idmef_additional_data_t *additional_data) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_ADDITIONAL_DATA_TYPE: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_additional_data_set_type(additional_data, tmp);
+ break;
+ }
+
+ case MSG_ADDITIONAL_DATA_MEANING: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_additional_data_set_meaning(additional_data, tmp);
+ break;
+ }
+
+ case MSG_ADDITIONAL_DATA_DATA: {
+ idmef_data_t *tmp;
+
+ if ( extract_data_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_additional_data_set_data(additional_data, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return additional_data;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return additional_data;
+
+error:
+ /* idmef_additional_data_destroy(additional_data); */
+ return NULL;
+}
+
+idmef_classification_t *idmef_read_classification(prelude_msg_t *msg, \
idmef_classification_t *classification) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_CLASSIFICATION_ORIGIN: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_classification_set_origin(classification, tmp);
+ break;
+ }
+
+ case MSG_CLASSIFICATION_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_classification_set_name(classification, tmp);
+ break;
+ }
+
+ case MSG_CLASSIFICATION_URL: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_classification_set_url(classification, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return classification;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return classification;
+
+error:
+ /* idmef_classification_destroy(classification); */
+ return NULL;
+}
+
+idmef_userid_t *idmef_read_userid(prelude_msg_t *msg, idmef_userid_t *userid)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_USERID_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_userid_set_ident(userid, tmp);
+ break;
+ }
+
+ case MSG_USERID_TYPE: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_userid_set_type(userid, tmp);
+ break;
+ }
+
+ case MSG_USERID_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_userid_set_name(userid, tmp);
+ break;
+ }
+
+ case MSG_USERID_NUMBER: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_userid_set_number(userid, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return userid;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return userid;
+
+error:
+ /* idmef_userid_destroy(userid); */
+ return NULL;
+}
+
+idmef_user_t *idmef_read_user(prelude_msg_t *msg, idmef_user_t *user)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_USER_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_user_set_ident(user, tmp);
+ break;
+ }
+
+ case MSG_USER_CATEGORY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_user_set_category(user, tmp);
+ break;
+ }
+
+ case MSG_USERID_TAG: {
+ idmef_userid_t *tmp;
+
+ tmp = idmef_user_new_userid(user);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_userid(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return user;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return user;
+
+error:
+ /* idmef_user_destroy(user); */
+ return NULL;
+}
+
+idmef_address_t *idmef_read_address(prelude_msg_t *msg, idmef_address_t *address)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_ADDRESS_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_address_set_ident(address, tmp);
+ break;
+ }
+
+ case MSG_ADDRESS_CATEGORY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_address_set_category(address, tmp);
+ break;
+ }
+
+ case MSG_ADDRESS_VLAN_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_address_set_vlan_name(address, tmp);
+ break;
+ }
+
+ case MSG_ADDRESS_VLAN_NUM: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_address_set_vlan_num(address, tmp);
+ break;
+ }
+
+ case MSG_ADDRESS_ADDRESS: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_address_set_address(address, tmp);
+ break;
+ }
+
+ case MSG_ADDRESS_NETMASK: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_address_set_netmask(address, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return address;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return address;
+
+error:
+ /* idmef_address_destroy(address); */
+ return NULL;
+}
+
+idmef_process_t *idmef_read_process(prelude_msg_t *msg, idmef_process_t *process)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_PROCESS_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_process_set_ident(process, tmp);
+ break;
+ }
+
+ case MSG_PROCESS_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_process_set_name(process, tmp);
+ break;
+ }
+
+ case MSG_PROCESS_PID: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_process_set_pid(process, tmp);
+ break;
+ }
+
+ case MSG_PROCESS_PATH: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_process_set_path(process, tmp);
+ break;
+ }
+
+ case MSG_PROCESS_ARG: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_process_set_arg(process, tmp);
+ break;
+ }
+
+ case MSG_PROCESS_ENV: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_process_set_env(process, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return process;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return process;
+
+error:
+ /* idmef_process_destroy(process); */
+ return NULL;
+}
+
+idmef_webservice_t *idmef_read_webservice(prelude_msg_t *msg, idmef_webservice_t \
*webservice) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_WEBSERVICE_URL: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_webservice_set_url(webservice, tmp);
+ break;
+ }
+
+ case MSG_WEBSERVICE_CGI: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_webservice_set_cgi(webservice, tmp);
+ break;
+ }
+
+ case MSG_WEBSERVICE_HTTP_METHOD: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_webservice_set_http_method(webservice, tmp);
+ break;
+ }
+
+ case MSG_WEBSERVICE_ARG: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_webservice_set_arg(webservice, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return webservice;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return webservice;
+
+error:
+ /* idmef_webservice_destroy(webservice); */
+ return NULL;
+}
+
+idmef_snmpservice_t *idmef_read_snmpservice(prelude_msg_t *msg, idmef_snmpservice_t \
*snmpservice) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_SNMPSERVICE_OID: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_snmpservice_set_oid(snmpservice, tmp);
+ break;
+ }
+
+ case MSG_SNMPSERVICE_COMMUNITY: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_snmpservice_set_community(snmpservice, tmp);
+ break;
+ }
+
+ case MSG_SNMPSERVICE_COMMAND: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_snmpservice_set_command(snmpservice, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return snmpservice;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return snmpservice;
+
+error:
+ /* idmef_snmpservice_destroy(snmpservice); */
+ return NULL;
+}
+
+idmef_service_t *idmef_read_service(prelude_msg_t *msg, idmef_service_t *service)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_SERVICE_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_service_set_ident(service, tmp);
+ break;
+ }
+
+ case MSG_SERVICE_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_service_set_name(service, tmp);
+ break;
+ }
+
+ case MSG_SERVICE_PORT: {
+ uint16_t tmp;
+
+ if ( extract_uint16_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_service_set_port(service, tmp);
+ break;
+ }
+
+ case MSG_SERVICE_PORTLIST: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_service_set_portlist(service, tmp);
+ break;
+ }
+
+ case MSG_SERVICE_PROTOCOL: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_service_set_protocol(service, tmp);
+ break;
+ }
+
+ case MSG_WEBSERVICE_TAG: {
+ idmef_webservice_t *tmp;
+
+ tmp = idmef_service_new_web(service);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_webservice(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_SNMPSERVICE_TAG: {
+ idmef_snmpservice_t *tmp;
+
+ tmp = idmef_service_new_snmp(service);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_snmpservice(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return service;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return service;
+
+error:
+ /* idmef_service_destroy(service); */
+ return NULL;
+}
+
+idmef_node_t *idmef_read_node(prelude_msg_t *msg, idmef_node_t *node)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_NODE_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_node_set_ident(node, tmp);
+ break;
+ }
+
+ case MSG_NODE_CATEGORY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_node_set_category(node, tmp);
+ break;
+ }
+
+ case MSG_NODE_LOCATION: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_node_set_location(node, tmp);
+ break;
+ }
+
+ case MSG_NODE_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_node_set_name(node, tmp);
+ break;
+ }
+
+ case MSG_ADDRESS_TAG: {
+ idmef_address_t *tmp;
+
+ tmp = idmef_node_new_address(node);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_address(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return node;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return node;
+
+error:
+ /* idmef_node_destroy(node); */
+ return NULL;
+}
+
+idmef_source_t *idmef_read_source(prelude_msg_t *msg, idmef_source_t *source)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_SOURCE_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_source_set_ident(source, tmp);
+ break;
+ }
+
+ case MSG_SOURCE_SPOOFED: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_source_set_spoofed(source, tmp);
+ break;
+ }
+
+ case MSG_SOURCE_INTERFACE: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_source_set_interface(source, tmp);
+ break;
+ }
+
+ case MSG_NODE_TAG: {
+ idmef_node_t *tmp;
+
+ tmp = idmef_source_new_node(source);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_node(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_USER_TAG: {
+ idmef_user_t *tmp;
+
+ tmp = idmef_source_new_user(source);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_user(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_PROCESS_TAG: {
+ idmef_process_t *tmp;
+
+ tmp = idmef_source_new_process(source);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_process(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_SERVICE_TAG: {
+ idmef_service_t *tmp;
+
+ tmp = idmef_source_new_service(source);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_service(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return source;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return source;
+
+error:
+ /* idmef_source_destroy(source); */
+ return NULL;
+}
+
+idmef_file_access_t *idmef_read_file_access(prelude_msg_t *msg, idmef_file_access_t \
*file_access) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_USERID_TAG: {
+ idmef_userid_t *tmp;
+
+ tmp = idmef_file_access_new_userid(file_access);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_userid(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_FILE_ACCESS_PERMISSION: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_access_set_permission(file_access, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return file_access;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return file_access;
+
+error:
+ /* idmef_file_access_destroy(file_access); */
+ return NULL;
+}
+
+idmef_inode_t *idmef_read_inode(prelude_msg_t *msg, idmef_inode_t *inode)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_INODE_CHANGE_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_inode_set_change_time(inode, tmp);
+ break;
+ }
+
+ case MSG_INODE_NUMBER: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_inode_set_number(inode, tmp);
+ break;
+ }
+
+ case MSG_INODE_MAJOR_DEVICE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_inode_set_major_device(inode, tmp);
+ break;
+ }
+
+ case MSG_INODE_MINOR_DEVICE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_inode_set_minor_device(inode, tmp);
+ break;
+ }
+
+ case MSG_INODE_C_MAJOR_DEVICE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_inode_set_c_major_device(inode, tmp);
+ break;
+ }
+
+ case MSG_INODE_C_MINOR_DEVICE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_inode_set_c_minor_device(inode, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return inode;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return inode;
+
+error:
+ /* idmef_inode_destroy(inode); */
+ return NULL;
+}
+
+idmef_file_t *idmef_read_file(prelude_msg_t *msg, idmef_file_t *file)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_FILE_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_ident(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_CATEGORY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_category(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_FSTYPE: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_fstype(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_name(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_PATH: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_path(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_CREATE_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_create_time(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_MODIFY_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_modify_time(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_ACCESS_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_access_time(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_DATA_SIZE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_data_size(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_DISK_SIZE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_file_set_disk_size(file, tmp);
+ break;
+ }
+
+ case MSG_FILE_ACCESS_TAG: {
+ idmef_file_access_t *tmp;
+
+ tmp = idmef_file_new_file_access(file);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_file_access(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_LINKAGE_TAG: {
+ idmef_linkage_t *tmp;
+
+ tmp = idmef_file_new_file_linkage(file);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_linkage(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_INODE_TAG: {
+ idmef_inode_t *tmp;
+
+ tmp = idmef_file_new_inode(file);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_inode(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return file;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return file;
+
+error:
+ /* idmef_file_destroy(file); */
+ return NULL;
+}
+
+idmef_linkage_t *idmef_read_linkage(prelude_msg_t *msg, idmef_linkage_t *linkage)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_LINKAGE_CATEGORY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_linkage_set_category(linkage, tmp);
+ break;
+ }
+
+ case MSG_LINKAGE_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_linkage_set_name(linkage, tmp);
+ break;
+ }
+
+ case MSG_LINKAGE_PATH: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_linkage_set_path(linkage, tmp);
+ break;
+ }
+
+ case MSG_FILE_TAG: {
+ idmef_file_t *tmp;
+
+ tmp = idmef_linkage_new_file(linkage);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_file(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return linkage;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return linkage;
+
+error:
+ /* idmef_linkage_destroy(linkage); */
+ return NULL;
+}
+
+idmef_target_t *idmef_read_target(prelude_msg_t *msg, idmef_target_t *target)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_TARGET_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_target_set_ident(target, tmp);
+ break;
+ }
+
+ case MSG_TARGET_DECOY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_target_set_decoy(target, tmp);
+ break;
+ }
+
+ case MSG_TARGET_INTERFACE: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_target_set_interface(target, tmp);
+ break;
+ }
+
+ case MSG_NODE_TAG: {
+ idmef_node_t *tmp;
+
+ tmp = idmef_target_new_node(target);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_node(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_USER_TAG: {
+ idmef_user_t *tmp;
+
+ tmp = idmef_target_new_user(target);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_user(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_PROCESS_TAG: {
+ idmef_process_t *tmp;
+
+ tmp = idmef_target_new_process(target);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_process(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_SERVICE_TAG: {
+ idmef_service_t *tmp;
+
+ tmp = idmef_target_new_service(target);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_service(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_FILE_TAG: {
+ idmef_file_t *tmp;
+
+ tmp = idmef_target_new_file(target);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_file(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return target;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return target;
+
+error:
+ /* idmef_target_destroy(target); */
+ return NULL;
+}
+
+idmef_analyzer_t *idmef_read_analyzer(prelude_msg_t *msg, idmef_analyzer_t \
*analyzer) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_ANALYZER_ANALYZERID: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_analyzerid(analyzer, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_MANUFACTURER: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_manufacturer(analyzer, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_MODEL: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_model(analyzer, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_VERSION: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_version(analyzer, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_CLASS: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_class(analyzer, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_OSTYPE: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_ostype(analyzer, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_OSVERSION: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_analyzer_set_osversion(analyzer, tmp);
+ break;
+ }
+
+ case MSG_NODE_TAG: {
+ idmef_node_t *tmp;
+
+ tmp = idmef_analyzer_new_node(analyzer);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_node(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_PROCESS_TAG: {
+ idmef_process_t *tmp;
+
+ tmp = idmef_analyzer_new_process(analyzer);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_process(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return analyzer;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return analyzer;
+
+error:
+ /* idmef_analyzer_destroy(analyzer); */
+ return NULL;
+}
+
+idmef_alertident_t *idmef_read_alertident(prelude_msg_t *msg, idmef_alertident_t \
*alertident) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_ALERTIDENT_ALERTIDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_alertident_set_alertident(alertident, tmp);
+ break;
+ }
+
+ case MSG_ALERTIDENT_ANALYZERID: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_alertident_set_analyzerid(alertident, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return alertident;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return alertident;
+
+error:
+ /* idmef_alertident_destroy(alertident); */
+ return NULL;
+}
+
+idmef_impact_t *idmef_read_impact(prelude_msg_t *msg, idmef_impact_t *impact)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_IMPACT_SEVERITY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_impact_set_severity(impact, tmp);
+ break;
+ }
+
+ case MSG_IMPACT_COMPLETION: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_impact_set_completion(impact, tmp);
+ break;
+ }
+
+ case MSG_IMPACT_TYPE: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_impact_set_type(impact, tmp);
+ break;
+ }
+
+ case MSG_IMPACT_DESCRIPTION: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_impact_set_description(impact, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return impact;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return impact;
+
+error:
+ /* idmef_impact_destroy(impact); */
+ return NULL;
+}
+
+idmef_action_t *idmef_read_action(prelude_msg_t *msg, idmef_action_t *action)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_ACTION_CATEGORY: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_action_set_category(action, tmp);
+ break;
+ }
+
+ case MSG_ACTION_DESCRIPTION: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_action_set_description(action, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return action;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return action;
+
+error:
+ /* idmef_action_destroy(action); */
+ return NULL;
+}
+
+idmef_confidence_t *idmef_read_confidence(prelude_msg_t *msg, idmef_confidence_t \
*confidence) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_CONFIDENCE_RATING: {
+ int32_t tmp;
+
+ if ( extract_int32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_confidence_set_rating(confidence, tmp);
+ break;
+ }
+
+ case MSG_CONFIDENCE_CONFIDENCE: {
+ float tmp;
+
+ if ( extract_float_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_confidence_set_confidence(confidence, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return confidence;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return confidence;
+
+error:
+ /* idmef_confidence_destroy(confidence); */
+ return NULL;
+}
+
+idmef_assessment_t *idmef_read_assessment(prelude_msg_t *msg, idmef_assessment_t \
*assessment) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_IMPACT_TAG: {
+ idmef_impact_t *tmp;
+
+ tmp = idmef_assessment_new_impact(assessment);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_impact(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_ACTION_TAG: {
+ idmef_action_t *tmp;
+
+ tmp = idmef_assessment_new_action(assessment);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_action(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_CONFIDENCE_TAG: {
+ idmef_confidence_t *tmp;
+
+ tmp = idmef_assessment_new_confidence(assessment);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_confidence(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return assessment;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return assessment;
+
+error:
+ /* idmef_assessment_destroy(assessment); */
+ return NULL;
+}
+
+idmef_tool_alert_t *idmef_read_tool_alert(prelude_msg_t *msg, idmef_tool_alert_t \
*tool_alert) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_TOOL_ALERT_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_tool_alert_set_name(tool_alert, tmp);
+ break;
+ }
+
+ case MSG_TOOL_ALERT_COMMAND: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_tool_alert_set_command(tool_alert, tmp);
+ break;
+ }
+
+ case MSG_ALERTIDENT_TAG: {
+ idmef_alertident_t *tmp;
+
+ tmp = idmef_tool_alert_new_alertident(tool_alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_alertident(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return tool_alert;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return tool_alert;
+
+error:
+ /* idmef_tool_alert_destroy(tool_alert); */
+ return NULL;
+}
+
+idmef_correlation_alert_t *idmef_read_correlation_alert(prelude_msg_t *msg, \
idmef_correlation_alert_t *correlation_alert) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_CORRELATION_ALERT_NAME: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_correlation_alert_set_name(correlation_alert, tmp);
+ break;
+ }
+
+ case MSG_ALERTIDENT_TAG: {
+ idmef_alertident_t *tmp;
+
+ tmp = idmef_correlation_alert_new_alertident(correlation_alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_alertident(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return correlation_alert;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return correlation_alert;
+
+error:
+ /* idmef_correlation_alert_destroy(correlation_alert); */
+ return NULL;
+}
+
+idmef_overflow_alert_t *idmef_read_overflow_alert(prelude_msg_t *msg, \
idmef_overflow_alert_t *overflow_alert) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_OVERFLOW_ALERT_PROGRAM: {
+ idmef_string_t *tmp;
+
+ if ( extract_string_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_overflow_alert_set_program(overflow_alert, tmp);
+ break;
+ }
+
+ case MSG_OVERFLOW_ALERT_SIZE: {
+ uint32_t tmp;
+
+ if ( extract_uint32_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_overflow_alert_set_size(overflow_alert, tmp);
+ break;
+ }
+
+ case MSG_OVERFLOW_ALERT_BUFFER: {
+ idmef_data_t *tmp;
+
+ if ( extract_data_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_overflow_alert_set_buffer(overflow_alert, tmp);
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return overflow_alert;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return overflow_alert;
+
+error:
+ /* idmef_overflow_alert_destroy(overflow_alert); */
+ return NULL;
+}
+
+idmef_alert_t *idmef_read_alert(prelude_msg_t *msg, idmef_alert_t *alert)
+{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_ALERT_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_alert_set_ident(alert, tmp);
+ break;
+ }
+
+ case MSG_ASSESSMENT_TAG: {
+ idmef_assessment_t *tmp;
+
+ tmp = idmef_alert_new_assessment(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_assessment(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_ANALYZER_TAG: {
+ idmef_analyzer_t *tmp;
+
+ tmp = idmef_alert_new_analyzer(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_analyzer(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_ALERT_CREATE_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_alert_set_create_time(alert, tmp);
+ break;
+ }
+
+ case MSG_ALERT_DETECT_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_alert_set_detect_time(alert, tmp);
+ break;
+ }
+
+ case MSG_ALERT_ANALYZER_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_alert_set_analyzer_time(alert, tmp);
+ break;
+ }
+
+ case MSG_SOURCE_TAG: {
+ idmef_source_t *tmp;
+
+ tmp = idmef_alert_new_source(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_source(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_TARGET_TAG: {
+ idmef_target_t *tmp;
+
+ tmp = idmef_alert_new_target(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_target(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_CLASSIFICATION_TAG: {
+ idmef_classification_t *tmp;
+
+ tmp = idmef_alert_new_classification(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_classification(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_ADDITIONAL_DATA_TAG: {
+ idmef_additional_data_t *tmp;
+
+ tmp = idmef_alert_new_additional_data(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_additional_data(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_TOOL_ALERT_TAG: {
+ idmef_tool_alert_t *tmp;
+
+ tmp = idmef_alert_new_tool_alert(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_tool_alert(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_CORRELATION_ALERT_TAG: {
+ idmef_correlation_alert_t *tmp;
+
+ tmp = idmef_alert_new_correlation_alert(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_correlation_alert(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_OVERFLOW_ALERT_TAG: {
+ idmef_overflow_alert_t *tmp;
+
+ tmp = idmef_alert_new_overflow_alert(alert);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_overflow_alert(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return alert;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return alert;
+
+error:
+ /* idmef_alert_destroy(alert); */
+ return NULL;
+}
+
+idmef_heartbeat_t *idmef_read_heartbeat(prelude_msg_t *msg, idmef_heartbeat_t \
*heartbeat) +{
+ void *buf;
+ uint8_t tag;
+ uint32_t len;
+
+ while ( 1 ) {
+
+ if ( prelude_msg_get(msg, &tag, &len, &buf) < 0 )
+ goto error;
+
+ switch ( tag ) {
+
+ case MSG_HEARTBEAT_IDENT: {
+ uint64_t tmp;
+
+ if ( extract_uint64_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_heartbeat_set_ident(heartbeat, tmp);
+ break;
+ }
+
+ case MSG_ANALYZER_TAG: {
+ idmef_analyzer_t *tmp;
+
+ tmp = idmef_heartbeat_new_analyzer(heartbeat);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_analyzer(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_HEARTBEAT_CREATE_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_heartbeat_set_create_time(heartbeat, tmp);
+ break;
+ }
+
+ case MSG_HEARTBEAT_ANALYZER_TIME: {
+ idmef_time_t *tmp;
+
+ if ( extract_time_safe(&tmp, buf, len) < 0 )
+ goto error;
+
+ idmef_heartbeat_set_analyzer_time(heartbeat, tmp);
+ break;
+ }
+
+ case MSG_ADDITIONAL_DATA_TAG: {
+ idmef_additional_data_t *tmp;
+
+ tmp = idmef_heartbeat_new_additional_data(heartbeat);
+ if ( ! tmp)
+ goto error;
+
+ if ( ! idmef_read_additional_data(msg, tmp) )
+ goto error;
+
+ break;
+ }
+
+ case MSG_END_OF_TAG:
+ return heartbeat;
+
+ default:
+ log(LOG_ERR, "couldn't handle tag %d.\n", tag);
+ goto error;
+ }
+
+ }
+
+ return heartbeat;
+
+error:
+ /* idmef_heartbeat_destroy(heartbeat); */
+ return NULL;
+}
+
+/*
+ * It is up to the caller to implement the toplevel function in order to handle
+ * specific stuff
+ */
Added: trunk/libprelude/src/idmef-message-write.c
===================================================================
--- trunk/libprelude/src/idmef-message-write.c 2004-03-06 20:46:32 UTC (rev 3499)
+++ trunk/libprelude/src/idmef-message-write.c 2004-03-09 21:10:04 UTC (rev 3500)
@@ -0,0 +1,760 @@
+
+/* Auto-generated by the GenerateIDMEFMessageWriteC package (Tue Mar 9 21:16:00 \
2004) */ +
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+
+#include "list.h"
+#include "prelude-log.h"
+#include "prelude-io.h"
+#include "prelude-message.h"
+#include "prelude-message-buffered.h"
+#include "prelude-message-id.h"
+#include "idmef-message-id.h"
+#include "idmef.h"
+#include "idmef-tree-wrap.h"
+#include "idmef-message-write.h"
+#include "sensor.h"
+#include "prelude-client.h"
+#include "common.h"
+
+/*
+ * If you wonder why we do this, and why life is complicated,
+ * then wonder why the hell the guys that wrote IDMEF choose to use XML.
+ * XML is dog slow. And XML'll never achieve performance needed for real time IDS.
+ *
+ * Here we are trying to communicate using a home made, binary version of IDMEF.
+ */
+
+
+static inline void idmef_write_string(prelude_msgbuf_t *msg, uint8_t tag, \
idmef_string_t *string) +{
+ if ( ! string || ! idmef_string_get_string(string) )
+ return;
+
+ prelude_msgbuf_set(msg, tag, idmef_string_get_len(string), \
idmef_string_get_string(string)); +}
+
+
+
+static inline void idmef_write_uint64(prelude_msgbuf_t *msg, uint8_t tag, uint64_t \
data) +{
+ uint64_t dst;
+
+ if ( data == 0 )
+ return;
+
+ dst = prelude_hton64(data);
+
+ prelude_msgbuf_set(msg, tag, sizeof(dst), &dst);
+}
+
+
+
+static inline void idmef_write_uint32(prelude_msgbuf_t *msg, uint8_t tag, uint32_t \
data) +{
+ if ( data == 0 )
+ return;
+
+ data = htonl(data);
+ prelude_msgbuf_set(msg, tag, sizeof(data), &data);
+}
+
+
+
+static inline void idmef_write_uint16(prelude_msgbuf_t *msg, uint8_t tag, uint16_t \
data) +{
+ if ( data == 0 )
+ return;
+
+ data = htons(data);
+ prelude_msgbuf_set(msg, tag, sizeof(data), &data);
+}
+
+
+
+static inline void idmef_write_float(prelude_msgbuf_t *msg, uint8_t tag, float data)
+{
+ if ( data == 0.0 )
+ return;
+
+ prelude_msgbuf_set(msg, tag, sizeof (data), &data);
+}
+
+
+
+inline void idmef_write_time(prelude_msgbuf_t *msg, uint8_t tag, idmef_time_t *data) \
+{
+ idmef_time_t dst;
+
+ if ( ! data)
+ return;
+
+ idmef_time_set_sec(&dst, htonl(idmef_time_get_sec(data)));
+ idmef_time_set_usec(&dst, htonl(idmef_time_get_usec(data)));
+
+ prelude_msgbuf_set(msg, tag, sizeof (dst), &dst);
+}
+
+
+
+static inline void idmef_write_data(prelude_msgbuf_t *msg, uint8_t tag, idmef_data_t \
*data) +{
+ if ( ! data )
+ return;
+
+ prelude_msgbuf_set(msg, tag, idmef_data_get_len(data), idmef_data_get_data(data));
+}
+
+void idmef_write_additional_data(prelude_msgbuf_t *msg, idmef_additional_data_t \
*additional_data) +{
+ if ( ! additional_data )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ADDITIONAL_DATA_TAG, 0, NULL);
+
+ idmef_write_uint32(msg, MSG_ADDITIONAL_DATA_TYPE, \
idmef_additional_data_get_type(additional_data)); + idmef_write_string(msg, \
MSG_ADDITIONAL_DATA_MEANING, idmef_additional_data_get_meaning(additional_data)); + \
idmef_write_data(msg, MSG_ADDITIONAL_DATA_DATA, \
idmef_additional_data_get_data(additional_data)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_classification(prelude_msgbuf_t *msg, idmef_classification_t \
*classification) +{
+ if ( ! classification )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_CLASSIFICATION_TAG, 0, NULL);
+
+ idmef_write_uint32(msg, MSG_CLASSIFICATION_ORIGIN, \
idmef_classification_get_origin(classification)); + idmef_write_string(msg, \
MSG_CLASSIFICATION_NAME, idmef_classification_get_name(classification)); + \
idmef_write_string(msg, MSG_CLASSIFICATION_URL, \
idmef_classification_get_url(classification)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_userid(prelude_msgbuf_t *msg, idmef_userid_t *userid)
+{
+ if ( ! userid )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_USERID_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_USERID_IDENT, idmef_userid_get_ident(userid));
+ idmef_write_uint32(msg, MSG_USERID_TYPE, idmef_userid_get_type(userid));
+ idmef_write_string(msg, MSG_USERID_NAME, idmef_userid_get_name(userid));
+ idmef_write_uint32(msg, MSG_USERID_NUMBER, idmef_userid_get_number(userid));
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_user(prelude_msgbuf_t *msg, idmef_user_t *user)
+{
+ if ( ! user )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_USER_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_USER_IDENT, idmef_user_get_ident(user));
+ idmef_write_uint32(msg, MSG_USER_CATEGORY, idmef_user_get_category(user));
+
+ {
+ idmef_userid_t *userid = NULL;
+
+ while ( (userid = idmef_user_get_next_userid(user, userid)) ) {
+ idmef_write_userid(msg, userid);
+ }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_address(prelude_msgbuf_t *msg, idmef_address_t *address)
+{
+ if ( ! address )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ADDRESS_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_ADDRESS_IDENT, \
idmef_address_get_ident(address)); + idmef_write_uint32(msg, \
MSG_ADDRESS_CATEGORY, idmef_address_get_category(address)); + \
idmef_write_string(msg, MSG_ADDRESS_VLAN_NAME, idmef_address_get_vlan_name(address)); \
+ idmef_write_uint32(msg, MSG_ADDRESS_VLAN_NUM, \
idmef_address_get_vlan_num(address)); + idmef_write_string(msg, \
MSG_ADDRESS_ADDRESS, idmef_address_get_address(address)); + \
idmef_write_string(msg, MSG_ADDRESS_NETMASK, idmef_address_get_netmask(address)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_process(prelude_msgbuf_t *msg, idmef_process_t *process)
+{
+ if ( ! process )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_PROCESS_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_PROCESS_IDENT, \
idmef_process_get_ident(process)); + idmef_write_string(msg, MSG_PROCESS_NAME, \
idmef_process_get_name(process)); + idmef_write_uint32(msg, MSG_PROCESS_PID, \
idmef_process_get_pid(process)); + idmef_write_string(msg, MSG_PROCESS_PATH, \
idmef_process_get_path(process)); +
+ {
+ idmef_string_t *arg = NULL;
+
+ while ( (arg = idmef_process_get_next_arg(process, arg)) ) {
+ idmef_write_string(msg, MSG_PROCESS_ARG, arg);
+ }
+ }
+
+
+ {
+ idmef_string_t *env = NULL;
+
+ while ( (env = idmef_process_get_next_env(process, env)) ) {
+ idmef_write_string(msg, MSG_PROCESS_ENV, env);
+ }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_webservice(prelude_msgbuf_t *msg, idmef_webservice_t *webservice)
+{
+ if ( ! webservice )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_WEBSERVICE_TAG, 0, NULL);
+
+ idmef_write_string(msg, MSG_WEBSERVICE_URL, \
idmef_webservice_get_url(webservice)); + idmef_write_string(msg, \
MSG_WEBSERVICE_CGI, idmef_webservice_get_cgi(webservice)); + \
idmef_write_string(msg, MSG_WEBSERVICE_HTTP_METHOD, \
idmef_webservice_get_http_method(webservice)); +
+ {
+ idmef_string_t *arg = NULL;
+
+ while ( (arg = idmef_webservice_get_next_arg(webservice, arg)) ) {
+ idmef_write_string(msg, MSG_WEBSERVICE_ARG, arg);
+ }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_snmpservice(prelude_msgbuf_t *msg, idmef_snmpservice_t \
*snmpservice) +{
+ if ( ! snmpservice )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_SNMPSERVICE_TAG, 0, NULL);
+
+ idmef_write_string(msg, MSG_SNMPSERVICE_OID, \
idmef_snmpservice_get_oid(snmpservice)); + idmef_write_string(msg, \
MSG_SNMPSERVICE_COMMUNITY, idmef_snmpservice_get_community(snmpservice)); + \
idmef_write_string(msg, MSG_SNMPSERVICE_COMMAND, \
idmef_snmpservice_get_command(snmpservice)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_service(prelude_msgbuf_t *msg, idmef_service_t *service)
+{
+ if ( ! service )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_SERVICE_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_SERVICE_IDENT, \
idmef_service_get_ident(service)); + idmef_write_string(msg, MSG_SERVICE_NAME, \
idmef_service_get_name(service)); + idmef_write_uint16(msg, MSG_SERVICE_PORT, \
idmef_service_get_port(service)); + idmef_write_string(msg, \
MSG_SERVICE_PORTLIST, idmef_service_get_portlist(service)); + \
idmef_write_string(msg, MSG_SERVICE_PROTOCOL, idmef_service_get_protocol(service)); +
+ switch ( idmef_service_get_type(service) ) {
+
+ case IDMEF_SERVICE_TYPE_WEB:
+ idmef_write_webservice(msg, idmef_service_get_web(service));
+ break;
+
+ case IDMEF_SERVICE_TYPE_SNMP:
+ idmef_write_snmpservice(msg, \
idmef_service_get_snmp(service)); + break;
+
+ default:
+ /* nop */;
+
+ }
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_node(prelude_msgbuf_t *msg, idmef_node_t *node)
+{
+ if ( ! node )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_NODE_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_NODE_IDENT, idmef_node_get_ident(node));
+ idmef_write_uint32(msg, MSG_NODE_CATEGORY, idmef_node_get_category(node));
+ idmef_write_string(msg, MSG_NODE_LOCATION, idmef_node_get_location(node));
+ idmef_write_string(msg, MSG_NODE_NAME, idmef_node_get_name(node));
+
+ {
+ idmef_address_t *address = NULL;
+
+ while ( (address = idmef_node_get_next_address(node, address)) ) {
+ idmef_write_address(msg, address);
+ }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_source(prelude_msgbuf_t *msg, idmef_source_t *source)
+{
+ if ( ! source )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_SOURCE_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_SOURCE_IDENT, idmef_source_get_ident(source));
+ idmef_write_uint32(msg, MSG_SOURCE_SPOOFED, \
idmef_source_get_spoofed(source)); + idmef_write_string(msg, \
MSG_SOURCE_INTERFACE, idmef_source_get_interface(source)); + \
idmef_write_node(msg, idmef_source_get_node(source)); + idmef_write_user(msg, \
idmef_source_get_user(source)); + idmef_write_process(msg, \
idmef_source_get_process(source)); + idmef_write_service(msg, \
idmef_source_get_service(source)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_file_access(prelude_msgbuf_t *msg, idmef_file_access_t \
*file_access) +{
+ if ( ! file_access )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_FILE_ACCESS_TAG, 0, NULL);
+
+ idmef_write_userid(msg, idmef_file_access_get_userid(file_access));
+
+ {
+ idmef_string_t *permission = NULL;
+
+ while ( (permission = \
idmef_file_access_get_next_permission(file_access, permission)) ) { + \
idmef_write_string(msg, MSG_FILE_ACCESS_PERMISSION, permission); + }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_inode(prelude_msgbuf_t *msg, idmef_inode_t *inode)
+{
+ if ( ! inode )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_INODE_TAG, 0, NULL);
+
+ idmef_write_time(msg, MSG_INODE_CHANGE_TIME, \
idmef_inode_get_change_time(inode)); + idmef_write_uint32(msg, \
MSG_INODE_NUMBER, idmef_inode_get_number(inode)); + idmef_write_uint32(msg, \
MSG_INODE_MAJOR_DEVICE, idmef_inode_get_major_device(inode)); + \
idmef_write_uint32(msg, MSG_INODE_MINOR_DEVICE, idmef_inode_get_minor_device(inode)); \
+ idmef_write_uint32(msg, MSG_INODE_C_MAJOR_DEVICE, \
idmef_inode_get_c_major_device(inode)); + idmef_write_uint32(msg, \
MSG_INODE_C_MINOR_DEVICE, idmef_inode_get_c_minor_device(inode)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_linkage(prelude_msgbuf_t *, idmef_linkage_t *);
+
+void idmef_write_file(prelude_msgbuf_t *msg, idmef_file_t *file)
+{
+ if ( ! file )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_FILE_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_FILE_IDENT, idmef_file_get_ident(file));
+ idmef_write_uint32(msg, MSG_FILE_CATEGORY, idmef_file_get_category(file));
+ idmef_write_uint32(msg, MSG_FILE_FSTYPE, idmef_file_get_fstype(file));
+ idmef_write_string(msg, MSG_FILE_NAME, idmef_file_get_name(file));
+ idmef_write_string(msg, MSG_FILE_PATH, idmef_file_get_path(file));
+ idmef_write_time(msg, MSG_FILE_CREATE_TIME, \
idmef_file_get_create_time(file)); + idmef_write_time(msg, \
MSG_FILE_MODIFY_TIME, idmef_file_get_modify_time(file)); + \
idmef_write_time(msg, MSG_FILE_ACCESS_TIME, idmef_file_get_access_time(file)); + \
idmef_write_uint32(msg, MSG_FILE_DATA_SIZE, idmef_file_get_data_size(file)); + \
idmef_write_uint32(msg, MSG_FILE_DISK_SIZE, idmef_file_get_disk_size(file)); +
+ {
+ idmef_file_access_t *file_access = NULL;
+
+ while ( (file_access = idmef_file_get_next_file_access(file, \
file_access)) ) { + idmef_write_file_access(msg, file_access);
+ }
+ }
+
+
+ {
+ idmef_linkage_t *file_linkage = NULL;
+
+ while ( (file_linkage = idmef_file_get_next_file_linkage(file, \
file_linkage)) ) { + idmef_write_linkage(msg, file_linkage);
+ }
+ }
+
+ idmef_write_inode(msg, idmef_file_get_inode(file));
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_linkage(prelude_msgbuf_t *msg, idmef_linkage_t *linkage)
+{
+ if ( ! linkage )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_LINKAGE_TAG, 0, NULL);
+
+ idmef_write_uint32(msg, MSG_LINKAGE_CATEGORY, \
idmef_linkage_get_category(linkage)); + idmef_write_string(msg, \
MSG_LINKAGE_NAME, idmef_linkage_get_name(linkage)); + idmef_write_string(msg, \
MSG_LINKAGE_PATH, idmef_linkage_get_path(linkage)); + idmef_write_file(msg, \
idmef_linkage_get_file(linkage)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_target(prelude_msgbuf_t *msg, idmef_target_t *target)
+{
+ if ( ! target )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_TARGET_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_TARGET_IDENT, idmef_target_get_ident(target));
+ idmef_write_uint32(msg, MSG_TARGET_DECOY, idmef_target_get_decoy(target));
+ idmef_write_string(msg, MSG_TARGET_INTERFACE, \
idmef_target_get_interface(target)); + idmef_write_node(msg, \
idmef_target_get_node(target)); + idmef_write_user(msg, \
idmef_target_get_user(target)); + idmef_write_process(msg, \
idmef_target_get_process(target)); + idmef_write_service(msg, \
idmef_target_get_service(target)); +
+ {
+ idmef_file_t *file = NULL;
+
+ while ( (file = idmef_target_get_next_file(target, file)) ) {
+ idmef_write_file(msg, file);
+ }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_analyzer(prelude_msgbuf_t *msg, idmef_analyzer_t *analyzer)
+{
+ if ( ! analyzer )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ANALYZER_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_ANALYZER_ANALYZERID, \
idmef_analyzer_get_analyzerid(analyzer)); + idmef_write_string(msg, \
MSG_ANALYZER_MANUFACTURER, idmef_analyzer_get_manufacturer(analyzer)); + \
idmef_write_string(msg, MSG_ANALYZER_MODEL, idmef_analyzer_get_model(analyzer)); + \
idmef_write_string(msg, MSG_ANALYZER_VERSION, idmef_analyzer_get_version(analyzer)); \
+ idmef_write_string(msg, MSG_ANALYZER_CLASS, \
idmef_analyzer_get_class(analyzer)); + idmef_write_string(msg, \
MSG_ANALYZER_OSTYPE, idmef_analyzer_get_ostype(analyzer)); + \
idmef_write_string(msg, MSG_ANALYZER_OSVERSION, \
idmef_analyzer_get_osversion(analyzer)); + idmef_write_node(msg, \
idmef_analyzer_get_node(analyzer)); + idmef_write_process(msg, \
idmef_analyzer_get_process(analyzer)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_alertident(prelude_msgbuf_t *msg, idmef_alertident_t *alertident)
+{
+ if ( ! alertident )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ALERTIDENT_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_ALERTIDENT_ALERTIDENT, \
idmef_alertident_get_alertident(alertident)); + idmef_write_uint64(msg, \
MSG_ALERTIDENT_ANALYZERID, idmef_alertident_get_analyzerid(alertident)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_impact(prelude_msgbuf_t *msg, idmef_impact_t *impact)
+{
+ if ( ! impact )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_IMPACT_TAG, 0, NULL);
+
+ idmef_write_uint32(msg, MSG_IMPACT_SEVERITY, \
idmef_impact_get_severity(impact)); + idmef_write_uint32(msg, \
MSG_IMPACT_COMPLETION, idmef_impact_get_completion(impact)); + \
idmef_write_uint32(msg, MSG_IMPACT_TYPE, idmef_impact_get_type(impact)); + \
idmef_write_string(msg, MSG_IMPACT_DESCRIPTION, \
idmef_impact_get_description(impact)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_action(prelude_msgbuf_t *msg, idmef_action_t *action)
+{
+ if ( ! action )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ACTION_TAG, 0, NULL);
+
+ idmef_write_uint32(msg, MSG_ACTION_CATEGORY, \
idmef_action_get_category(action)); + idmef_write_string(msg, \
MSG_ACTION_DESCRIPTION, idmef_action_get_description(action)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_confidence(prelude_msgbuf_t *msg, idmef_confidence_t *confidence)
+{
+ if ( ! confidence )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_CONFIDENCE_TAG, 0, NULL);
+
+ idmef_write_uint32(msg, MSG_CONFIDENCE_RATING, \
idmef_confidence_get_rating(confidence)); + idmef_write_float(msg, \
MSG_CONFIDENCE_CONFIDENCE, idmef_confidence_get_confidence(confidence)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_assessment(prelude_msgbuf_t *msg, idmef_assessment_t *assessment)
+{
+ if ( ! assessment )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ASSESSMENT_TAG, 0, NULL);
+
+ idmef_write_impact(msg, idmef_assessment_get_impact(assessment));
+
+ {
+ idmef_action_t *action = NULL;
+
+ while ( (action = idmef_assessment_get_next_action(assessment, \
action)) ) { + idmef_write_action(msg, action);
+ }
+ }
+
+ idmef_write_confidence(msg, idmef_assessment_get_confidence(assessment));
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_tool_alert(prelude_msgbuf_t *msg, idmef_tool_alert_t *tool_alert)
+{
+ if ( ! tool_alert )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_TOOL_ALERT_TAG, 0, NULL);
+
+ idmef_write_string(msg, MSG_TOOL_ALERT_NAME, \
idmef_tool_alert_get_name(tool_alert)); + idmef_write_string(msg, \
MSG_TOOL_ALERT_COMMAND, idmef_tool_alert_get_command(tool_alert)); +
+ {
+ idmef_alertident_t *alertident = NULL;
+
+ while ( (alertident = \
idmef_tool_alert_get_next_alertident(tool_alert, alertident)) ) { + \
idmef_write_alertident(msg, alertident); + }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_correlation_alert(prelude_msgbuf_t *msg, idmef_correlation_alert_t \
*correlation_alert) +{
+ if ( ! correlation_alert )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_CORRELATION_ALERT_TAG, 0, NULL);
+
+ idmef_write_string(msg, MSG_CORRELATION_ALERT_NAME, \
idmef_correlation_alert_get_name(correlation_alert)); +
+ {
+ idmef_alertident_t *alertident = NULL;
+
+ while ( (alertident = \
idmef_correlation_alert_get_next_alertident(correlation_alert, alertident)) ) { + \
idmef_write_alertident(msg, alertident); + }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_overflow_alert(prelude_msgbuf_t *msg, idmef_overflow_alert_t \
*overflow_alert) +{
+ if ( ! overflow_alert )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_OVERFLOW_ALERT_TAG, 0, NULL);
+
+ idmef_write_string(msg, MSG_OVERFLOW_ALERT_PROGRAM, \
idmef_overflow_alert_get_program(overflow_alert)); + idmef_write_uint32(msg, \
MSG_OVERFLOW_ALERT_SIZE, idmef_overflow_alert_get_size(overflow_alert)); + \
idmef_write_data(msg, MSG_OVERFLOW_ALERT_BUFFER, \
idmef_overflow_alert_get_buffer(overflow_alert)); +
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_alert(prelude_msgbuf_t *msg, idmef_alert_t *alert)
+{
+ if ( ! alert )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_ALERT_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_ALERT_IDENT, idmef_alert_get_ident(alert));
+ idmef_write_assessment(msg, idmef_alert_get_assessment(alert));
+ idmef_write_analyzer(msg, idmef_alert_get_analyzer(alert));
+ idmef_write_time(msg, MSG_ALERT_CREATE_TIME, \
idmef_alert_get_create_time(alert)); + idmef_write_time(msg, \
MSG_ALERT_DETECT_TIME, idmef_alert_get_detect_time(alert)); + \
idmef_write_time(msg, MSG_ALERT_ANALYZER_TIME, idmef_alert_get_analyzer_time(alert)); \
+ + {
+ idmef_source_t *source = NULL;
+
+ while ( (source = idmef_alert_get_next_source(alert, source)) ) {
+ idmef_write_source(msg, source);
+ }
+ }
+
+
+ {
+ idmef_target_t *target = NULL;
+
+ while ( (target = idmef_alert_get_next_target(alert, target)) ) {
+ idmef_write_target(msg, target);
+ }
+ }
+
+
+ {
+ idmef_classification_t *classification = NULL;
+
+ while ( (classification = idmef_alert_get_next_classification(alert, \
classification)) ) { + idmef_write_classification(msg, \
classification); + }
+ }
+
+
+ {
+ idmef_additional_data_t *additional_data = NULL;
+
+ while ( (additional_data = \
idmef_alert_get_next_additional_data(alert, additional_data)) ) { + \
idmef_write_additional_data(msg, additional_data); + }
+ }
+
+
+ switch ( idmef_alert_get_type(alert) ) {
+
+ case IDMEF_ALERT_TYPE_TOOL:
+ idmef_write_tool_alert(msg, \
idmef_alert_get_tool_alert(alert)); + break;
+
+ case IDMEF_ALERT_TYPE_CORRELATION:
+ idmef_write_correlation_alert(msg, \
idmef_alert_get_correlation_alert(alert)); + break;
+
+ case IDMEF_ALERT_TYPE_OVERFLOW:
+ idmef_write_overflow_alert(msg, \
idmef_alert_get_overflow_alert(alert)); + break;
+
+ default:
+ /* nop */;
+
+ }
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_heartbeat(prelude_msgbuf_t *msg, idmef_heartbeat_t *heartbeat)
+{
+ if ( ! heartbeat )
+ return;
+
+ prelude_msgbuf_set(msg, MSG_HEARTBEAT_TAG, 0, NULL);
+
+ idmef_write_uint64(msg, MSG_HEARTBEAT_IDENT, \
idmef_heartbeat_get_ident(heartbeat)); + idmef_write_analyzer(msg, \
idmef_heartbeat_get_analyzer(heartbeat)); + idmef_write_time(msg, \
MSG_HEARTBEAT_CREATE_TIME, idmef_heartbeat_get_create_time(heartbeat)); + \
idmef_write_time(msg, MSG_HEARTBEAT_ANALYZER_TIME, \
idmef_heartbeat_get_analyzer_time(heartbeat)); +
+ {
+ idmef_additional_data_t *additional_data = NULL;
+
+ while ( (additional_data = \
idmef_heartbeat_get_next_additional_data(heartbeat, additional_data)) ) { + \
idmef_write_additional_data(msg, additional_data); + }
+ }
+
+
+ prelude_msgbuf_set(msg, MSG_END_OF_TAG, 0, NULL);
+}
+
+
+void idmef_write_message(prelude_msgbuf_t *msg, idmef_message_t *message)
+{
+ if ( ! message )
+ return;
+
+ idmef_write_string(msg, MSG_MESSAGE_VERSION, \
idmef_message_get_version(message)); +
+ switch ( idmef_message_get_type(message) ) {
+
+ case IDMEF_MESSAGE_TYPE_ALERT:
+ idmef_write_alert(msg, idmef_message_get_alert(message));
+ break;
+
+ case IDMEF_MESSAGE_TYPE_HEARTBEAT:
+ idmef_write_heartbeat(msg, \
idmef_message_get_heartbeat(message)); + break;
+
+ default:
+ /* nop */;
+
+ }
+}
+
+
Modified: trunk/libprelude/src/idmef-tree-print.c
===================================================================
--- trunk/libprelude/src/idmef-tree-print.c 2004-03-06 20:46:32 UTC (rev 3499)
+++ trunk/libprelude/src/idmef-tree-print.c 2004-03-09 21:10:04 UTC (rev 3500)
@@ -1,5 +1,5 @@
-/* Auto-generated by the GenerateIDMEFTreePrintC package (Sat Mar 6 20:38:07 2004) \
*/ +/* Auto-generated by the GenerateIDMEFTreePrintC package (Tue Mar 9 21:16:00 \
2004) */
#include "idmef.h"
#include "idmef-tree-wrap.h"
Modified: trunk/libprelude/src/idmef-tree-to-string.c
===================================================================
--- trunk/libprelude/src/idmef-tree-to-string.c 2004-03-06 20:46:32 UTC (rev 3499)
+++ trunk/libprelude/src/idmef-tree-to-string.c 2004-03-09 21:10:04 UTC (rev 3500)
@@ -1,5 +1,5 @@
-/* Auto-generated by the GenerateIDMEFTreeToStringC package (Sat Mar 6 20:38:07 \
2004) */ +/* Auto-generated by the GenerateIDMEFTreeToStringC package (Tue Mar 9 \
21:16:00 2004) */
#include "idmef.h"
#include "idmef-util.h"
Modified: trunk/libprelude/src/include/idmef-message-id.h
===================================================================
--- trunk/libprelude/src/include/idmef-message-id.h 2004-03-06 20:46:32 UTC (rev \
3499)
+++ trunk/libprelude/src/include/idmef-message-id.h 2004-03-09 21:10:04 UTC (rev \
3500) @@ -1,5 +1,5 @@
-/* Auto-generated by the GenerateIDMEFMessageIdH package (Sat Mar 6 20:38:07 2004) \
*/ +/* Auto-generated by the GenerateIDMEFMessageIdH package (Tue Mar 9 21:16:00 \
2004) */
#ifndef _LIBPRELUDE_IDMEF_MESSAGE_ID_H
#define _LIBPRELUDE_IDMEF_MESSAGE_ID_H
Added: trunk/libprelude/src/include/idmef-message-read.h
===================================================================
--- trunk/libprelude/src/include/idmef-message-read.h 2004-03-06 20:46:32 UTC (rev \
3499)
+++ trunk/libprelude/src/include/idmef-message-read.h 2004-03-09 21:10:04 UTC (rev \
3500) @@ -0,0 +1,62 @@
+
+/* Auto-generated by the GenerateIDMEFMessageReadH package (Tue Mar 9 21:16:00 \
2004) */ +
+#ifndef _LIBPRELUDE_IDMEF_MESSAGE_READ_H
+#define _LIBPRELUDE_IDMEF_MESSAGE_READ_H
+
+
+idmef_additional_data_t *idmef_read_additional_data(prelude_msg_t *msg, \
idmef_additional_data_t *additional_data); +
+idmef_classification_t *idmef_read_classification(prelude_msg_t *msg, \
idmef_classification_t *classification); +
+idmef_userid_t *idmef_read_userid(prelude_msg_t *msg, idmef_userid_t *userid);
+
+idmef_user_t *idmef_read_user(prelude_msg_t *msg, idmef_user_t *user);
+
+idmef_address_t *idmef_read_address(prelude_msg_t *msg, idmef_address_t *address);
+
+idmef_process_t *idmef_read_process(prelude_msg_t *msg, idmef_process_t *process);
+
+idmef_webservice_t *idmef_read_webservice(prelude_msg_t *msg, idmef_webservice_t \
*webservice); +
+idmef_snmpservice_t *idmef_read_snmpservice(prelude_msg_t *msg, idmef_snmpservice_t \
*snmpservice); +
+idmef_service_t *idmef_read_service(prelude_msg_t *msg, idmef_service_t *service);
+
+idmef_node_t *idmef_read_node(prelude_msg_t *msg, idmef_node_t *node);
+
+idmef_source_t *idmef_read_source(prelude_msg_t *msg, idmef_source_t *source);
+
+idmef_file_access_t *idmef_read_file_access(prelude_msg_t *msg, idmef_file_access_t \
*file_access); +
+idmef_inode_t *idmef_read_inode(prelude_msg_t *msg, idmef_inode_t *inode);
+
+idmef_file_t *idmef_read_file(prelude_msg_t *msg, idmef_file_t *file);
+
+idmef_linkage_t *idmef_read_linkage(prelude_msg_t *msg, idmef_linkage_t *linkage);
+
+idmef_target_t *idmef_read_target(prelude_msg_t *msg, idmef_target_t *target);
+
+idmef_analyzer_t *idmef_read_analyzer(prelude_msg_t *msg, idmef_analyzer_t \
*analyzer); +
+idmef_alertident_t *idmef_read_alertident(prelude_msg_t *msg, idmef_alertident_t \
*alertident); +
+idmef_impact_t *idmef_read_impact(prelude_msg_t *msg, idmef_impact_t *impact);
+
+idmef_action_t *idmef_read_action(prelude_msg_t *msg, idmef_action_t *action);
+
+idmef_confidence_t *idmef_read_confidence(prelude_msg_t *msg, idmef_confidence_t \
*confidence); +
+idmef_assessment_t *idmef_read_assessment(prelude_msg_t *msg, idmef_assessment_t \
*assessment); +
+idmef_tool_alert_t *idmef_read_tool_alert(prelude_msg_t *msg, idmef_tool_alert_t \
*tool_alert); +
+idmef_correlation_alert_t *idmef_read_correlation_alert(prelude_msg_t *msg, \
idmef_correlation_alert_t *correlation_alert); +
+idmef_overflow_alert_t *idmef_read_overflow_alert(prelude_msg_t *msg, \
idmef_overflow_alert_t *overflow_alert); +
+idmef_alert_t *idmef_read_alert(prelude_msg_t *msg, idmef_alert_t *alert);
+
+idmef_heartbeat_t *idmef_read_heartbeat(prelude_msg_t *msg, idmef_heartbeat_t \
*heartbeat); +
+#endif /* _LIBPRELUDE_IDMEF_MESSAGE_READ_H */
Added: trunk/libprelude/src/include/idmef-message-write.h
===================================================================
--- trunk/libprelude/src/include/idmef-message-write.h 2004-03-06 20:46:32 UTC (rev \
3499)
+++ trunk/libprelude/src/include/idmef-message-write.h 2004-03-09 21:10:04 UTC (rev \
3500) @@ -0,0 +1,37 @@
+
+/* Auto-generated by the GenerateIDMEFMessageWriteH package (Tue Mar 9 21:16:00 \
2004) */ +
+#ifndef _LIBPRELUDE_IDMEF_MESSAGE_WRITE_H
+#define _LIBPRELUDE_IDMEF_MESSAGE_WRITE_H
+
+void idmef_write_time(prelude_msgbuf_t *msg, uint8_t tag, idmef_time_t *data);
+void idmef_write_additional_data(prelude_msgbuf_t *msg, idmef_additional_data_t \
*additional_data); +void idmef_write_classification(prelude_msgbuf_t *msg, \
idmef_classification_t *classification); +void idmef_write_userid(prelude_msgbuf_t \
*msg, idmef_userid_t *userid); +void idmef_write_user(prelude_msgbuf_t *msg, \
idmef_user_t *user); +void idmef_write_address(prelude_msgbuf_t *msg, idmef_address_t \
*address); +void idmef_write_process(prelude_msgbuf_t *msg, idmef_process_t \
*process); +void idmef_write_webservice(prelude_msgbuf_t *msg, idmef_webservice_t \
*webservice); +void idmef_write_snmpservice(prelude_msgbuf_t *msg, \
idmef_snmpservice_t *snmpservice); +void idmef_write_service(prelude_msgbuf_t *msg, \
idmef_service_t *service); +void idmef_write_node(prelude_msgbuf_t *msg, idmef_node_t \
*node); +void idmef_write_source(prelude_msgbuf_t *msg, idmef_source_t *source);
+void idmef_write_file_access(prelude_msgbuf_t *msg, idmef_file_access_t \
*file_access); +void idmef_write_inode(prelude_msgbuf_t *msg, idmef_inode_t *inode);
+void idmef_write_file(prelude_msgbuf_t *msg, idmef_file_t *file);
+void idmef_write_linkage(prelude_msgbuf_t *msg, idmef_linkage_t *linkage);
+void idmef_write_target(prelude_msgbuf_t *msg, idmef_target_t *target);
+void idmef_write_analyzer(prelude_msgbuf_t *msg, idmef_analyzer_t *analyzer);
+void idmef_write_alertident(prelude_msgbuf_t *msg, idmef_alertident_t *alertident);
+void idmef_write_impact(prelude_msgbuf_t *msg, idmef_impact_t *impact);
+void idmef_write_action(prelude_msgbuf_t *msg, idmef_action_t *action);
+void idmef_write_confidence(prelude_msgbuf_t *msg, idmef_confidence_t *confidence);
+void idmef_write_assessment(prelude_msgbuf_t *msg, idmef_assessment_t *assessment);
+void idmef_write_tool_alert(prelude_msgbuf_t *msg, idmef_tool_alert_t *tool_alert);
+void idmef_write_correlation_alert(prelude_msgbuf_t *msg, idmef_correlation_alert_t \
*correlation_alert); +void idmef_write_overflow_alert(prelude_msgbuf_t *msg, \
idmef_overflow_alert_t *overflow_alert); +void idmef_write_alert(prelude_msgbuf_t \
*msg, idmef_alert_t *alert); +void idmef_write_heartbeat(prelude_msgbuf_t *msg, \
idmef_heartbeat_t *heartbeat); +void idmef_write_message(prelude_msgbuf_t *msg, \
idmef_message_t *message); +
+#endif /* _LIBPRELUDE_IDMEF_MESSAGE_WRITE_H */
Modified: trunk/libprelude/src/include/idmef-tree-print.h
===================================================================
--- trunk/libprelude/src/include/idmef-tree-print.h 2004-03-06 20:46:32 UTC (rev \
3499)
+++ trunk/libprelude/src/include/idmef-tree-print.h 2004-03-09 21:10:04 UTC (rev \
3500) @@ -1,5 +1,5 @@
-/* Auto-generated by the GenerateIDMEFTreePrintH package (Sat Mar 6 20:38:07 2004) \
*/ +/* Auto-generated by the GenerateIDMEFTreePrintH package (Tue Mar 9 21:16:00 \
2004) */
#ifndef _LIBPRELUDE_IDMEF_TREE_PRINT_H
#define _LIBPRELUDE_IDMEF_TREE_PRINT_H
Modified: trunk/libprelude/src/include/idmef-tree-to-string.h
===================================================================
--- trunk/libprelude/src/include/idmef-tree-to-string.h 2004-03-06 20:46:32 UTC (rev \
3499)
+++ trunk/libprelude/src/include/idmef-tree-to-string.h 2004-03-09 21:10:04 UTC (rev \
3500) @@ -1,5 +1,5 @@
-/* Auto-generated by the GenerateIDMEFTreeToStringH package (Sat Mar 6 20:38:07 \
2004) */ +/* Auto-generated by the GenerateIDMEFTreeToStringH package (Tue Mar 9 \
21:16:00 2004) */
#ifndef _LIBPRELUDE_IDMEF_TREE_TO_STRING_H
#define _LIBPRELUDE_IDMEF_TREE_TO_STRING_H
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic