static int input_kismet_drone_open(struct input *i) {
struct input_kismet_drone_priv *priv = i->priv;
char *host = PTYPE_STRING_GETVAL(priv->p_host);
char *port = ptype_print_val_alloc(priv->p_port, NULL);
if (!port)
return POM_ERR;
struct addrinfo hints = { 0 };
//hints.ai_family = AF_UNSPEC;
hints.ai_family = AF_INET; // kismet_drone seem to only listen on ipv4 address
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = 0;
hints.ai_flags = AI_ADDRCONFIG;
struct addrinfo *res = NULL;
int err = getaddrinfo(host, port, &hints, &res);
free(port);
if (err) {
pomlog(POMLOG_ERR "Error while resolving hostname %s : %s", host, gai_strerror(err));
return POM_ERR;
}
priv->fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (priv->fd == -1) {
freeaddrinfo(res);
pomlog(POMLOG_ERR "Error while creating socket : %s", pom_strerror(errno));
return POM_ERR;
}
if (connect(priv->fd, res->ai_addr, res->ai_addrlen)) {
freeaddrinfo(res);
close(priv->fd);
priv->fd = -1;
pomlog(POMLOG_ERR "Error while connecting to Kismet drone : %s", pom_strerror(errno));
return POM_ERR;
}
freeaddrinfo(res);
pomlog("Connection established to Kismet drone %s:%u", host, *PTYPE_UINT16_GETVAL(priv->p_port));
return POM_OK;
}
int output_log_xml_process(struct event *evt, void *obj) {
struct output_log_xml_priv *priv = obj;
struct event_reg_info *evt_info = event_get_info(evt);
xmlBufferPtr buff = xmlBufferCreate();
if (!buff) {
pomlog(POMLOG_ERR "Error while creating the xml buffer");
return POM_ERR;
}
xmlTextWriterPtr writer = xmlNewTextWriterMemory(buff, 0);
if (!writer) {
pomlog(POMLOG_ERR "Error while creating the xmlTextWriter");
xmlBufferFree(buff);
return POM_ERR;
}
// <event name="event_name">
char timestamp[21] = { 0 };
snprintf(timestamp, 20, "%"PRIu64, (uint64_t) event_get_timestamp(evt));
if (xmlTextWriterWriteString(writer, BAD_CAST "\n") < 0 ||
xmlTextWriterStartElement(writer, BAD_CAST "event") < 0 ||
xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST evt_info->name) < 0 ||
xmlTextWriterWriteAttribute(writer, BAD_CAST "timestamp", BAD_CAST timestamp) < 0)
goto err;
struct data *evt_data = event_get_data(evt);
int i;
for (i = 0; i < evt_info->data_reg->data_count; i++) {
if (evt_info->data_reg->items[i].flags & DATA_REG_FLAG_LIST) {
// Got a data_list
if (!evt_data[i].items)
continue;
// <data_list name="data_name">
if (xmlTextWriterWriteString(writer, BAD_CAST "\n\t") < 0 ||
xmlTextWriterStartElement(writer, BAD_CAST "data_list") < 0 ||
xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST evt_info->data_reg->items[i].name) < 0)
goto err;
// <value key="key1">
struct data_item *itm = evt_data[i].items;
for (; itm; itm = itm->next) {
if (xmlTextWriterWriteString(writer, BAD_CAST "\n\t\t") < 0 ||
xmlTextWriterStartElement(writer, BAD_CAST "value") < 0 ||
xmlTextWriterWriteAttribute(writer, BAD_CAST "key", BAD_CAST itm->key) < 0)
goto err;
char *value = ptype_print_val_alloc(itm->value, NULL);
if (!value)
goto err;
if (xmlTextWriterWriteString(writer, BAD_CAST value) < 0) {
free(value);
goto err;
}
free(value);
// </value>
if (xmlTextWriterEndElement(writer) < 0)
goto err;
}
// </data_list>
if (xmlTextWriterWriteString(writer, BAD_CAST "\n\t") < 0 ||
xmlTextWriterEndElement(writer) < 0)
goto err;
} else {
// Got a single data
if (!data_is_set(evt_data[i]))
continue;
// <data name="data_name">
if (xmlTextWriterWriteString(writer, BAD_CAST "\n\t") < 0 ||
xmlTextWriterStartElement(writer, BAD_CAST "data") < 0 ||
xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST evt_info->data_reg->items[i].name) < 0)
goto err;
if (evt_data[i].value) {
char *value = ptype_print_val_alloc(evt_data[i].value, NULL);
if (!value)
goto err;
if (xmlTextWriterWriteString(writer, BAD_CAST value) < 0) {
free(value);
goto err;
}
free(value);
}
// </data>
if (xmlTextWriterEndElement(writer) < 0)
goto err;
}
}
// </event>
if (xmlTextWriterWriteString(writer, BAD_CAST "\n") < 0 ||
xmlTextWriterEndElement(writer) < 0 ||
xmlTextWriterWriteString(writer, BAD_CAST "\n") < 0)
goto err;
xmlFreeTextWriter(writer);
if (pom_write(priv->fd, buff->content, buff->use) != POM_OK) {
pomlog(POMLOG_ERR "Error while writing to the log file");
xmlBufferFree(buff);
return POM_ERR;
}
xmlBufferFree(buff);
if (priv->perf_events)
registry_perf_inc(priv->perf_events, 1);
return POM_OK;
err:
pomlog(POMLOG_ERR "An error occured while processing the event");
xmlFreeTextWriter(writer);
xmlBufferFree(buff);
return POM_ERR;
}
int registry_config_save(char *config_name) {
if (strlen(config_name) >= REGISTRY_CONFIG_NAME_MAX) {
pomlog(POMLOG_ERR "Configuration name too long, max %u characters.", REGISTRY_CONFIG_NAME_MAX);
return POM_ERR;
}
struct dataset_query *dsq_config_list = NULL, *dsq_config = NULL;
struct datastore *sys_dstore = system_datastore();
if (!sys_dstore)
return POM_ERR;
struct datastore_connection *dc = datastore_connection_new(sys_dstore);
if (!dc)
return POM_ERR;
dsq_config_list = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG_LIST, registry_config_list_dataset_template, dc);
if (!dsq_config_list)
goto err;
if (datastore_dataset_query_set_string_condition(dsq_config_list, 0, PTYPE_OP_EQ, config_name) != POM_OK)
goto err;
dsq_config = datastore_dataset_query_open(sys_dstore, REGISTRY_CONFIG, registry_config_dataset_template, dc);
if (!dsq_config)
goto err;
if (datastore_transaction_begin(dc) != POM_OK)
goto err;
// Find out if we already have a config by that name
int res = datastore_dataset_read_single(dsq_config_list);
if (res == DATASET_QUERY_MORE) {
// Delete existing stuff about this config
if (datastore_dataset_query_set_uint64_condition(dsq_config, 0, PTYPE_OP_EQ, dsq_config_list->data_id) != POM_OK)
goto err;
if (datastore_dataset_delete(dsq_config_list) != DATASET_QUERY_OK)
goto err;
if (datastore_dataset_delete(dsq_config) != DATASET_QUERY_OK)
goto err;
}
if (res < 0)
goto err;
// Add the config to the config list
PTYPE_STRING_SETVAL(dsq_config_list->values[0].value, config_name);
PTYPE_TIMESTAMP_SETVAL(dsq_config_list->values[1].value, pom_gettimeofday());
if (datastore_dataset_write(dsq_config_list) != DATASET_QUERY_OK)
goto err;
PTYPE_UINT64_SETVAL(dsq_config->values[0].value, dsq_config_list->data_id);
registry_lock();
struct registry_class *cls;
// Browse each class
for (cls = registry_head; cls; cls = cls->next) {
// Browse each instance of the class
struct registry_instance *inst;
for (inst = cls->instances; inst; inst = inst->next) {
// Don't add the instance if it's not added by the user
if (cls->instance_add) {
// The system datastore will always exist
if (inst == sys_dstore->reg_instance)
continue;
char *buff = malloc(strlen(cls->name) + 1 + strlen(inst->name) + 1);
if (!buff) {
pom_oom(strlen(cls->name) + 1 + strlen(inst->name) + 1);
goto err_locked;
}
strcpy(buff, cls->name);
strcat(buff, ".");
strcat(buff, inst->name);
PTYPE_STRING_SETVAL_P(dsq_config->values[1].value, buff);
struct registry_param *p;
for (p = inst->params; p && strcmp(p->name, "type"); p = p->next);
if (p) {
dsq_config->values[2].is_null = 0;
char *type = PTYPE_STRING_GETVAL(p->value);
PTYPE_STRING_SETVAL(dsq_config->values[2].value, type);
} else {
dsq_config->values[2].is_null = 1;
}
PTYPE_UINT8_SETVAL(dsq_config->values[3].value, registry_config_instance);
if (datastore_dataset_write(dsq_config) != DATASET_QUERY_OK)
goto err_locked;
}
// Browse the parametrers and add the non default ones
struct registry_param *param;
for (param = inst->params; param; param = param->next) {
// Check if the parameter value is not the default one anymore
if (param->default_value) {
struct ptype *defval = ptype_alloc_from(param->value);
if (!defval)
goto err_locked;
if (ptype_parse_val(defval, param->default_value) != POM_OK) {
pomlog(POMLOG_ERR "Unable to parse default value !");
ptype_cleanup(defval);
goto err_locked;
}
if (ptype_compare_val(PTYPE_OP_EQ, param->value, defval)) {
// Param still has the default value, do nothing
ptype_cleanup(defval);
continue;
}
ptype_cleanup(defval);
}
char *buff = malloc(strlen(cls->name) + 1 + strlen(inst->name) + 1 + strlen(param->name) + 1);
if (!buff) {
pom_oom(strlen(cls->name) + 1 + strlen(inst->name) + 1 + strlen(param->name) + 1);
goto err_locked;
}
strcpy(buff, cls->name);
strcat(buff, ".");
strcat(buff, inst->name);
strcat(buff, ".");
strcat(buff, param->name);
PTYPE_STRING_SETVAL_P(dsq_config->values[1].value, buff);
char *value = ptype_print_val_alloc(param->value, NULL);
if (!value)
goto err_locked;
dsq_config->values[2].is_null = 0;
PTYPE_STRING_SETVAL_P(dsq_config->values[2].value, value);
PTYPE_UINT8_SETVAL(dsq_config->values[3].value, registry_config_instance_param);
if (datastore_dataset_write(dsq_config) != DATASET_QUERY_OK)
goto err_locked;
}
}
}
registry_config_serial++;
registry_serial++;
xmlrcpcmd_serial_inc();
registry_unlock();
if (datastore_transaction_commit(dc) != POM_OK)
goto err;
datastore_dataset_query_cleanup(dsq_config_list);
datastore_dataset_query_cleanup(dsq_config);
datastore_connection_release(dc);
pomlog("Registry configuration saved as \"%s\"", config_name);
return POM_OK;
err_locked:
registry_unlock();
err:
if (dsq_config_list)
datastore_dataset_query_cleanup(dsq_config_list);
if (dsq_config)
datastore_dataset_query_cleanup(dsq_config);
if (dc) {
datastore_transaction_rollback(dc);
datastore_connection_release(dc);
}
return POM_ERR;
}
