int
agent_flush_erroneous_container(worker_t *worker, GError **error)
{
GError *error_local = NULL;
request_t *req = NULL;
struct namespace_data_s *ns_data = NULL;
char ns_name[LIMIT_LENGTH_NSNAME+1];
gsize req_param_length;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
/*parse the request args, find the namespace*/
req = (request_t*) worker->data.session;
req_param_length = req->arg ? strlen(req->arg) : 0;
if (req_param_length<=0 || req_param_length>=LIMIT_LENGTH_NSNAME)
return __respond_message(worker, 0, "Invalid REQUEST format", error);
g_memmove( ns_name, req->arg, req_param_length);
ns_data = get_namespace(ns_name, &error_local);
if (!ns_data || !ns_data->configured)
return __respond_message(worker, 0, "NAMESPACE not found/ready", error);
DEBUG("Flushing the broken elements on [%s]", ns_name);
/*free outgoing data*/
if (ns_data->list_broken) {
g_slist_foreach( ns_data->list_broken, g_free1, NULL);
g_slist_free( ns_data->list_broken);
ns_data->list_broken = NULL;
}
/* Ask a distant flush, on the conscience */
if (!create_sub_worker(ns_data, worker, &error_local)) {
GSETERROR(&error_local, "Failed to connect to the conscience");
return __respond_error(worker, error_local, error);
}
/*free incomed data*/
if (ns_data->conscience && ns_data->conscience->broken_elements)
broken_holder_flush( ns_data->conscience->broken_elements );
if (error_local)
g_clear_error(&error_local);
worker->func = agent_worker_default_func;
return 1;
}
int
services_worker_push(worker_t * worker, GError ** error)
{
gboolean rc;
GSList *list_service_info = NULL, *l;
/*extract the fields packed in the request's parameter */
request_t *req = (request_t *) worker->data.session;
rc = service_info_unmarshall(&list_service_info, req->arg, req->arg_size, error);
if (!rc) {
GSETERROR(error, "Invalid payload (service_info sequence expected)");
return 0;
}
/*push all the services */
for (l = list_service_info; l; l = l->next) {
if (!l->data)
continue;
if (!manage_service(l->data))
service_info_clean(l->data);
l->data = NULL;
}
g_slist_free(list_service_info);
list_service_info = NULL;
return __respond_message(worker, 1, "OK", error);
}
int
agent_store_erroneous_container(worker_t *worker, GError **error)
{
GError *error_local = NULL;
gchar ns_name[LIMIT_LENGTH_NSNAME], broken_element[2048], **tokens;
request_t *req = NULL;
namespace_data_t *ns_data = NULL;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
memset(broken_element, 0x00, sizeof(broken_element));
if (!flag_manage_broken)
return __respond_message(worker, 0, "Broken elements not managed", error);
/*extract the fields packed in the request's parameter*/
req = (request_t*)worker->data.session;
tokens = buffer_split( req->arg, req->arg_size, ":", 2);
if (!tokens) {
GSETERROR(&error_local, "Invalid format (0)");
return 0;
}
else if (!tokens[0] || !tokens[1]) {
g_strfreev(tokens);
return __respond_message(worker, 0, "Invalid REQUEST format", error);
}
g_strlcpy(ns_name, tokens[0], sizeof(ns_name)-1);
g_strlcpy(broken_element, tokens[1], sizeof(broken_element)-1);
g_strfreev(tokens);
tokens = NULL;
DEBUG("[NS=%s] broken element received [%s]", ns_name, broken_element);
/* Get an initiated namespace data */
ns_data = get_namespace(ns_name, NULL);
if (!ns_data || !ns_data->configured)
return __respond_message(worker, 0, "NAMESPACE not found/ready", error);
if (!broken_holder_check_element_format( ns_data->conscience->broken_elements, broken_element))
return __respond_message(worker, 0, "Invalid ELEMENT format", error);
/*Element seems OK, keep it*/
ns_data->list_broken = g_slist_prepend(ns_data->list_broken, g_strdup(broken_element));
return __respond_message(worker, 1, "OK", error);
}
int
agent_receive_event_worker(worker_t *worker, GError **error)
{
GError *error_local;
worker_data_t *data;
request_t *req;
gchar ns_name[LIMIT_LENGTH_NSNAME+1];
struct namespace_data_s *ns_data;
const char *encoded_event;
gsize ns_name_len, encoded_event_size;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
ns_name_len = encoded_event_size = 0;
error_local = NULL;
data = &(worker->data);
req = (request_t*)data->session;
/* Unpack the NAMESPACE name and the EVENT serialized form:
* format: NAMESPACE\e00<BUFFER>*/
g_memmove(ns_name, req->arg, MIN(sizeof(ns_name)-1,req->arg_size));
ns_name_len = strlen(ns_name);
encoded_event = req->arg + (ns_name_len+1);
encoded_event_size = req->arg_size - (ns_name_len+1);
/* Check namespace */
if (!*ns_name)
return __respond_message(worker, 0, "Invalid format", error);
DEBUG("[ns=%s] Received an event of %"G_GSIZE_FORMAT" bytes (from %d)", ns_name, encoded_event_size, req->arg_size);
if (!(ns_data = g_hash_table_lookup(namespaces, ns_name)))
return __respond_message(worker, 0, "Unknown namespace '%s'", error);
if (!event_enable_receive)
return __respond_message(worker, 0, "Events not managed on this host", error);
if (!save_event_bytes(ns_data, (guint8*)encoded_event, encoded_event_size, &error_local))
return __respond_error(worker, error_local, error);
return __respond_message(worker, 1, "OK, event saved", error);
}
static int
asn1_final_handler( worker_t *worker, GError **error )
{
worker_t *original_worker;
TRACE_POSITION();
original_worker = asn1_worker_get_session_data(worker);
if (!original_worker) {
GSETERROR(error,"Request successful but reply failed due to invalid worker");
return 0;
}
__respond_message( original_worker, 1, "OK", NULL );
return 1;
}
