[prev in list] [next in list] [prev in thread] [next in thread]
List: prelude-cvslog
Subject: [prelude-cvslog] r9853 - prelude-manager/trunk/src
From: noreply () prelude-ids ! org
Date: 2007-08-23 17:43:21
Message-ID: 20070823174321.82112DD9B7D () mail ! prelude-ids ! org
[Download RAW message or body]
Author: yoann
Date: 2007-08-23 19:43:15 +0200 (Thu, 23 Aug 2007)
New Revision: 9853
Modified:
prelude-manager/trunk/src/sensor-server.c
Log:
Whitespace police.
Modified: prelude-manager/trunk/src/sensor-server.c
===================================================================
--- prelude-manager/trunk/src/sensor-server.c 2007-08-23 16:24:24 UTC (rev 9852)
+++ prelude-manager/trunk/src/sensor-server.c 2007-08-23 17:43:15 UTC (rev 9853)
@@ -1,6 +1,6 @@
/*****
*
-* Copyright (C) 2001, 2002, 2003, 2004, 2005 PreludeIDS Technologies. All Rights \
Reserved. +* Copyright (C) 2001-2005,2006,2007 PreludeIDS Technologies. All Rights \
Reserved.
* Author: Yoann Vandoorselaere <yoann.v@prelude-ids.com>
*
* This file is part of the Prelude-Manager program.
@@ -63,14 +63,14 @@
-static sensor_fd_t *search_client(prelude_list_t *head, uint64_t analyzerid, \
uint32_t instance_id) +static sensor_fd_t *search_client(prelude_list_t *head, \
uint64_t analyzerid, uint32_t instance_id) {
sensor_fd_t *client;
prelude_list_t *tmp;
prelude_list_for_each(head, tmp) {
client = prelude_list_entry(tmp, sensor_fd_t, list);
-
+
if ( client->ident == analyzerid && (! instance_id || instance_id == \
client->instance_id) ) return client;
}
@@ -84,9 +84,9 @@
{
int ret;
- ret = prelude_msg_write(msg, dst->fd);
+ ret = prelude_msg_write(msg, dst->fd);
if ( ret < 0 && prelude_error_get_code(ret) == PRELUDE_ERROR_EAGAIN ) {
-
+
prelude_linked_object_add(&dst->write_msg_list, \
(prelude_linked_object_t *) msg);
server_logic_notify_write_enable((server_logic_client_t *) dst);
@@ -95,23 +95,23 @@
if ( ret != 0 )
prelude_log(PRELUDE_LOG_ERR, "could not write msg: %s.\n", \
prelude_strerror(ret));
-
+
prelude_msg_destroy(msg);
-
+
return ret;
}
-
+
static int forward_message_to_analyzerid(sensor_fd_t *client, uint64_t analyzerid, \
uint32_t instance_no, prelude_msg_t *msg) {
int ret = 0;
uint8_t tag;
sensor_fd_t *target;
-
+
ret = pthread_mutex_lock(&sensors_list_mutex);
tag = prelude_msg_get_tag(msg);
-
+
target = search_client(&sensors_cnx_list, analyzerid, instance_no);
if ( ! target ) {
pthread_mutex_unlock(&sensors_list_mutex);
@@ -141,7 +141,7 @@
sensor_server_write_client((server_generic_client_t *) target, msg);
out:
pthread_mutex_unlock(&sensors_list_mutex);
-
+
return ret;
}
@@ -160,21 +160,21 @@
*target_ptr = NULL;
*instance_ptr = NULL;
-
+
while ( prelude_msg_get(msg, &tag, &len, &buf) == 0 ) {
if ( tag == PRELUDE_MSG_OPTION_TARGET_INSTANCE_ID ) {
if ( len != sizeof(uint32_t) )
return -1;
-
+
*instance_ptr = buf;
}
-
+
if ( tag == PRELUDE_MSG_OPTION_TARGET_ID ) {
-
+
if ( *target_ptr || (len % sizeof(uint64_t)) != 0 || len < 2 \
* sizeof(uint64_t) ) break;
-
+
target_len = len;
*target_ptr = buf;
}
@@ -184,38 +184,38 @@
if ( ! *target_ptr || ! *instance_ptr )
break;
-
+
ret = prelude_extract_uint32_safe(&hop, buf, len);
if ( ret < 0 )
break;
-
+
if ( hop == 0 )
break;
- ret = (direction == PRELUDE_MSG_OPTION_REQUEST) ? hop - 1 : hop + 1;
- if ( ret < 0 || ret >= (target_len / sizeof(uint64_t)) )
- break;
-
- ident = prelude_extract_uint64(&(*target_ptr)[ret]);
+ ret = (direction == PRELUDE_MSG_OPTION_REQUEST) ? hop - 1 : hop + 1;
+ if ( ret < 0 || ret >= (target_len / sizeof(uint64_t)) )
+ break;
+
+ ident = prelude_extract_uint64(&(*target_ptr)[ret]);
if ( ident != client->ident )
return prelude_error_verbose(PRELUDE_ERROR_GENERIC, "client \
attempt to mask source identifier");
-
+
hop = (direction == PRELUDE_MSG_OPTION_REQUEST) ? hop + 1 : hop - 1;
- if ( ret < 0 || ret >= (target_len / sizeof(uint64_t)) )
- break;
-
- if ( hop == (target_len / sizeof(uint64_t)) ) { \
+ if ( ret < 0 || ret >= (target_len / sizeof(uint64_t)) )
+ break;
+
+ if ( hop == (target_len / sizeof(uint64_t)) ) {
*hop_ptr = (hop - 1);
return 0; /* we are the target */
}
-
+
tmp = htonl(hop);
memcpy(buf, &tmp, sizeof(tmp));
-
+
if ( hop >= (target_len / sizeof(uint64_t)) )
break;
- *hop_ptr = hop;
+ *hop_ptr = hop;
return 0;
}
@@ -241,11 +241,11 @@
prelude_msg_set(msg, PRELUDE_MSG_OPTION_TARGET_ID, hop * sizeof(uint64_t), \
ident_list);
/*
- * cancel the hop increment done previously, and position on target.
- * this function is only supposed to be called for failed request (not failed \
reply).
- */
+ * cancel the hop increment done previously, and position on target.
+ * this function is only supposed to be called for failed request (not \
failed reply). + */
- hop -= 2;
+ hop -= 2;
prelude_msg_set(msg, PRELUDE_MSG_OPTION_HOP, sizeof(hop), &hop);
return sensor_server_write_client(client, msg);
@@ -253,13 +253,13 @@
-static int process_request_cb(prelude_msgbuf_t *msgbuf, prelude_msg_t *msg)
+static int process_request_cb(prelude_msgbuf_t *msgbuf, prelude_msg_t *msg)
{
int ret;
ret = sensor_server_write_client(prelude_msgbuf_get_data(msgbuf), msg);
if ( ret < 0 && prelude_error_get_code(ret) == PRELUDE_ERROR_EAGAIN )
return 0; /* message is queued */
-
+
return ret;
}
@@ -284,7 +284,7 @@
idmef_message_scheduler_stop_processing();
ret = prelude_option_process_request(dst, msg, buf);
idmef_message_scheduler_start_processing();
-
+
prelude_msgbuf_destroy(buf);
return ret;
@@ -292,7 +292,7 @@
-static int request_sensor_option(server_generic_client_t *client, prelude_msg_t \
*msg) +static int request_sensor_option(server_generic_client_t *client, \
prelude_msg_t *msg) {
int ret;
uint64_t ident;
@@ -300,12 +300,12 @@
uint32_t target_hop, *instance_id;
sensor_fd_t *sclient = (sensor_fd_t *) client;
prelude_client_profile_t *cp = prelude_client_get_profile(manager_client);
-
+
ret = get_msg_target_ident(sclient, msg, &target_route,
&target_hop, &instance_id, \
PRELUDE_MSG_OPTION_REQUEST);
- if ( ret < 0 )
+ if ( ret < 0 )
return ret;
-
+
/*
* We receive an option request from client.
*
@@ -319,7 +319,7 @@
prelude_msg_destroy(msg);
return 0;
}
-
+
ident = prelude_extract_uint64(&target_route[target_hop]);
if ( ident == prelude_client_profile_get_analyzerid(cp) ) {
prelude_msg_recycle(msg);
@@ -329,55 +329,55 @@
}
*instance_id = htonl(sclient->instance_id);
-
+
ret = forward_message_to_analyzerid(sclient, ident, 0, msg);
if ( ret == -1 ) {
send_unreachable_message(client, target_route, target_hop, \
TARGET_UNREACHABLE, sizeof(TARGET_UNREACHABLE)); prelude_msg_destroy(msg);
}
-
+
if ( ret == -2 ) {
send_unreachable_message(client, target_route, target_hop, \
TARGET_PROHIBITED, sizeof(TARGET_PROHIBITED)); prelude_msg_destroy(msg);
}
-
+
return 0;
}
-static int reply_sensor_option(sensor_fd_t *client, prelude_msg_t *msg)
+static int reply_sensor_option(sensor_fd_t *client, prelude_msg_t *msg)
{
int ret;
uint64_t *target_route, ident;
uint32_t target_hop, *instance_no;
-
+
ret = get_msg_target_ident(client, msg, &target_route, &target_hop, \
&instance_no, PRELUDE_MSG_OPTION_REPLY); if ( ret < 0 )
return ret;
-
+
ident = prelude_extract_uint64(&target_route[target_hop]);
-
+
/*
* The one replying the option doesn't care about client presence or not.
*/
ret = forward_message_to_analyzerid(client, ident, \
prelude_extract_uint32(instance_no), msg); if ( ret < 0 )
prelude_msg_destroy(msg);
-
+
return 0;
}
-static int handle_declare_receiver(sensor_fd_t *sclient)
+static int handle_declare_receiver(sensor_fd_t *sclient)
{
int ret;
server_generic_client_t *client = (server_generic_client_t *) sclient;
-
+
if ( ! sclient->ident )
return -1;
-
+
sclient->rrr = reverse_relay_search_receiver(sclient->ident);
if ( ! sclient->rrr ) {
/*
@@ -399,19 +399,19 @@
-static int handle_declare_client(sensor_fd_t *cnx)
+static int handle_declare_client(sensor_fd_t *cnx)
{
cnx->queue = idmef_message_scheduler_queue_new(manager_client);
if ( ! cnx->queue )
return -1;
-
+
pthread_mutex_lock(&sensors_list_mutex);
-
+
cnx->instance_id = ++global_instance_id;
prelude_list_add_tail(&sensors_cnx_list, &cnx->list);
pthread_mutex_unlock(&sensors_list_mutex);
-
+
return 0;
}
@@ -423,17 +423,17 @@
void *nul;
uint32_t len;
uint8_t permission;
-
+
prelude_msg_get(msg, &permission, &len, &nul);
-
+
if ( permission & PRELUDE_CONNECTION_PERMISSION_IDMEF_READ ) {
-
+
if ( ! (cnx->permission & PRELUDE_CONNECTION_PERMISSION_IDMEF_READ) \
) {
server_generic_log_client((server_generic_client_t *) cnx, \
PRELUDE_LOG_WARN,
"insufficient credentials to read \
IDMEF message: closing connection.\n"); return -1;
}
-
+
ret = handle_declare_receiver(cnx);
if ( ret < 0 )
return ret;
@@ -449,7 +449,7 @@
static int handle_msg(sensor_fd_t *client, prelude_msg_t *msg, uint8_t tag)
{
int ret;
-
+
if ( tag == PRELUDE_MSG_IDMEF ) {
/*
* We receive a message from a client
@@ -467,29 +467,29 @@
ret = idmef_message_schedule(client->queue, msg);
}
-
+
else if ( tag == PRELUDE_MSG_OPTION_REQUEST )
ret = request_sensor_option((server_generic_client_t *) client, \
msg);
-
+
else if ( tag == PRELUDE_MSG_OPTION_REPLY )
ret = reply_sensor_option(client, msg);
else if ( tag == PRELUDE_MSG_CONNECTION_CAPABILITY )
ret = handle_capability(client, msg);
-
+
else {
/* unknown message, ignore silently for backward compatibility */
prelude_msg_destroy(msg);
return 0;
}
-
+
if ( ret < 0 ) {
prelude_msg_destroy(msg);
server_generic_log_client((server_generic_client_t *) client, \
PRELUDE_LOG_WARN,
"error processing peer message: %s.\n", \
prelude_strerror(ret)); return -1;
}
-
+
return ret;
}
@@ -504,20 +504,20 @@
ret = prelude_msg_read(&cnx->msg, cnx->fd);
if ( ret < 0 ) {
prelude_error_code_t code = prelude_error_get_code(ret);
-
- if ( code == PRELUDE_ERROR_EAGAIN )
+
+ if ( code == PRELUDE_ERROR_EAGAIN )
return 0;
-
+
cnx->msg = NULL;
if ( code != PRELUDE_ERROR_EOF )
server_generic_log_client((server_generic_client_t *) cnx, \
PRELUDE_LOG_WARN, "%s.\n", prelude_strerror(ret));
-
+
return -1;
}
-
+
msg = cnx->msg;
cnx->msg = NULL;
-
+
ret = handle_msg(cnx, msg, prelude_msg_get_tag(msg));
if ( ret < 0 )
return ret;
@@ -533,9 +533,9 @@
prelude_list_t *tmp;
prelude_msg_t *cur = NULL;
sensor_fd_t *sclient = (sensor_fd_t *) client;
-
+
pthread_mutex_lock(&sclient->mutex);
-
+
prelude_list_for_each(&sclient->write_msg_list, tmp) {
cur = prelude_linked_object_get_object(tmp);
prelude_linked_object_del((prelude_linked_object_t *) cur);
@@ -549,11 +549,11 @@
return 0;
}
}
-
+
if ( prelude_list_is_empty(&sclient->write_msg_list) ) {
server_logic_notify_write_disable((server_logic_client_t *) client);
pthread_mutex_unlock(&sclient->mutex);
-
+
if ( server_generic_client_get_state(client) & \
SERVER_GENERIC_CLIENT_STATE_FLUSHING )
ret = reverse_relay_set_receiver_alive(sclient->rrr, \
client);
@@ -561,7 +561,7 @@
}
pthread_mutex_unlock(&sclient->mutex);
-
+
return 1; /* We yet have other message to process */
}
@@ -572,7 +572,7 @@
int ret;
void *fd_ptr;
prelude_error_code_t code;
-
+
do {
ret = prelude_connection_close(cnx->cnx);
if ( ret == 0 )
@@ -580,16 +580,16 @@
code = prelude_error_get_code(ret);
if ( code == PRELUDE_ERROR_EAGAIN ) {
-
+
fd_ptr = \
prelude_io_get_fdptr(prelude_connection_get_fd(cnx->cnx));
if ( fd_ptr && gnutls_record_get_direction(fd_ptr) == 1 )
\
server_logic_notify_write_enable((server_logic_client_t *) ptr);
-
+
return -1;
}
server_generic_log_client(ptr, PRELUDE_LOG_WARN, "%s.\n", \
prelude_strerror(ret));
-
+
} while ( ret < 0 && ! \
prelude_io_is_error_fatal(prelude_connection_get_fd(cnx->cnx), ret));
return 0;
@@ -597,16 +597,16 @@
-static int close_connection_cb(server_generic_client_t *ptr)
+static int close_connection_cb(server_generic_client_t *ptr)
{
int ret;
prelude_msg_t *msg;
prelude_list_t *tmp, *bkp;
sensor_fd_t *cnx = (sensor_fd_t *) ptr;
-
+
if ( cnx->rrr )
reverse_relay_set_receiver_dead(cnx->rrr);
-
+
else if ( cnx->cnx ) {
cnx->fd = NULL;
reverse_relay_set_initiator_dead(cnx->cnx);
@@ -615,20 +615,20 @@
if ( ret < 0 )
return -1;
}
-
-
+
+
if ( ! prelude_list_is_empty(&cnx->list) ) {
pthread_mutex_lock(&sensors_list_mutex);
prelude_list_del(&cnx->list);
pthread_mutex_unlock(&sensors_list_mutex);
}
-
+
prelude_list_for_each_safe(&cnx->write_msg_list, tmp, bkp) {
msg = prelude_linked_object_get_object(tmp);
prelude_linked_object_del((prelude_linked_object_t *) msg);
prelude_msg_destroy(msg);
}
-
+
/*
* If cnx->msg is not NULL, it mean the sensor
* closed the connection without finishing to send
@@ -641,49 +641,49 @@
idmef_message_scheduler_queue_destroy(cnx->queue);
pthread_mutex_destroy(&cnx->mutex);
-
+
return 0;
}
-static int accept_connection_cb(server_generic_client_t *ptr)
+static int accept_connection_cb(server_generic_client_t *ptr)
{
int ret;
sensor_fd_t *fd = (sensor_fd_t *) ptr;
-
- fd->we_connected = FALSE;
+
+ fd->we_connected = FALSE;
prelude_list_init(&fd->list);
prelude_list_init(&fd->write_msg_list);
pthread_mutex_init(&fd->mutex, NULL);
-
+
ret = handle_declare_client(fd);
if ( ret < 0 )
return -1;
-
+
return 1; /* more data might be available, the caller shall keep reading */
}
-server_generic_t *sensor_server_new(void)
+server_generic_t *sensor_server_new(void)
{
server_generic_t *server;
-
+
server = server_generic_new(sizeof(sensor_fd_t), accept_connection_cb,
read_connection_cb, write_connection_cb, \
close_connection_cb); if ( ! server ) {
prelude_log(PRELUDE_LOG_WARN, "error creating a generic server.\n");
return NULL;
}
-
+
return server;
}
-void sensor_server_stop(server_generic_t *server)
+void sensor_server_stop(server_generic_t *server)
{
server_generic_stop(server);
}
@@ -691,10 +691,10 @@
-int sensor_server_add_client(server_generic_t *server, server_generic_client_t \
**client, prelude_connection_t *cnx) +int sensor_server_add_client(server_generic_t \
*server, server_generic_client_t **client, prelude_connection_t *cnx) {
sensor_fd_t *cdata;
-
+
cdata = calloc(1, sizeof(*cdata));
if ( ! cdata ) {
prelude_log(PRELUDE_LOG_ERR, "memory exhausted.\n");
@@ -702,51 +702,51 @@
}
*client = (server_generic_client_t *) cdata;
-
+
cdata->addr = strdup(prelude_connection_get_peer_addr(cnx));
if ( ! cdata->addr ) {
prelude_log(PRELUDE_LOG_ERR, "memory exhausted.\n");
free(cdata);
return -1;
}
-
+
cdata->queue = idmef_message_scheduler_queue_new(manager_client);
if ( ! cdata->queue ) {
free(cdata->addr);
free(cdata);
return -1;
}
-
+
cdata->state |= SERVER_GENERIC_CLIENT_STATE_ACCEPTED;
cdata->fd = prelude_connection_get_fd(cnx);
-
+
cdata->cnx = cnx;
cdata->rrr = NULL;
cdata->we_connected = TRUE;
pthread_mutex_init(&cdata->mutex, NULL);
prelude_list_init(&cdata->write_msg_list);
cdata->ident = prelude_connection_get_peer_analyzerid(cnx);
-
+
server_generic_client_set_permission((server_generic_client_t *)cdata, \
prelude_connection_get_permission(cnx));
-
- pthread_mutex_lock(&sensors_list_mutex);
+
+ pthread_mutex_lock(&sensors_list_mutex);
prelude_list_add(&sensors_cnx_list, &cdata->list);
pthread_mutex_unlock(&sensors_list_mutex);
-
+
server_generic_process_requests(server, (server_generic_client_t *) cdata);
-
+
return 0;
}
-int sensor_server_write_client(server_generic_client_t *client, prelude_msg_t *msg)
+int sensor_server_write_client(server_generic_client_t *client, prelude_msg_t *msg)
{
int ret;
sensor_fd_t *dst = (sensor_fd_t *) client;
-
+
pthread_mutex_lock(&dst->mutex);
- if ( prelude_list_is_empty(&dst->write_msg_list) )
+ if ( prelude_list_is_empty(&dst->write_msg_list) )
ret = write_client(dst, msg);
else {
ret = 0;
@@ -754,21 +754,21 @@
}
pthread_mutex_unlock(&dst->mutex);
-
+
return ret;
}
-void sensor_server_queue_write_client(server_generic_client_t *client, prelude_msg_t \
*msg) +void sensor_server_queue_write_client(server_generic_client_t *client, \
prelude_msg_t *msg) {
sensor_fd_t *dst = (sensor_fd_t *) client;
-
+
pthread_mutex_lock(&dst->mutex);
-
+
if ( prelude_list_is_empty(&dst->write_msg_list) )
server_logic_notify_write_enable((server_logic_client_t *) dst);
-
+
prelude_linked_object_add_tail(&dst->write_msg_list, \
(prelude_linked_object_t *) msg); pthread_mutex_unlock(&dst->mutex);
}
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic