/*
* Loads filename into memory, we use append_line() for that.
*/
static int load_file_in_memory(config_t *cfg)
{
int ret;
FILE *fd;
size_t len;
prelude_string_t *out;
char line[1024], *ptr, *tmp;
ret = prelude_string_new(&out);
if ( ret < 0 )
return ret;
fd = fopen(cfg->filename, "r");
if ( ! fd ) {
prelude_string_destroy(out);
return prelude_error_verbose(prelude_error_code_from_errno(errno), "could not open '%s' for reading: %s",
cfg->filename, strerror(errno));
}
do {
len = 0;
ptr = fgets(line, sizeof(line), fd);
if ( ptr ) {
len = strlen(line);
if ( line[len - 1] == '\n' )
line[len - 1] = 0;
ret = prelude_string_cat(out, line);
if ( ret < 0 )
goto err;
if ( line[len - 1] != 0 )
continue;
}
ret = prelude_string_get_string_released(out, &tmp);
if ( ret < 0 )
goto err;
if ( ! tmp )
tmp = strdup("");
ret = op_append_line(cfg, tmp);
if ( ret < 0 ) {
free(tmp);
goto err;
}
prelude_string_clear(out);
} while ( ptr );
err:
prelude_string_destroy(out);
fclose(fd);
return 0;
}
/**
* prelude_string_clone:
* @src: Pointer to an existing #prelude_string_t object.
* @dst: Pointer to an address where to store the created #prelude_string_t object.
*
* Clone @src within a new #prelude_string_t object stored into @dst.
* Data carried by @dst and @src are independant.
*
* Returns: 0 on success, or a negative value if an error occured.
*/
int prelude_string_clone(const prelude_string_t *src, prelude_string_t **dst)
{
int ret;
prelude_return_val_if_fail(src, prelude_error(PRELUDE_ERROR_ASSERTION));
ret = prelude_string_new(dst);
if ( ret < 0 )
return ret;
(*dst)->size = src->size;
(*dst)->index = src->index;
(*dst)->flags |= PRELUDE_STRING_OWN_DATA;
if ( src->size ) {
(*dst)->data.rwbuf = malloc(src->size);
if ( ! (*dst)->data.rwbuf ) {
prelude_string_destroy(*dst);
return prelude_error_from_errno(errno);
}
string_buf_copy(*dst, src->data.robuf, src->index);
}
return 0;
}
static int btime_print(const idmef_criterion_value_t *cv, prelude_io_t *fd)
{
int ret;
prelude_string_t *out;
ret = prelude_string_new(&out);
if ( ret < 0 )
return ret;
ret = btime_to_string(cv, out);
if ( ret < 0 ) {
prelude_string_destroy(out);
return ret;
}
ret = prelude_io_write(fd, prelude_string_get_string(out), prelude_string_get_len(out));
prelude_string_destroy(out);
return ret;
}
void server_generic_log_client(server_generic_client_t *cnx, prelude_log_t priority, const char *fmt, ...)
{
va_list ap;
int ret = 0;
prelude_string_t *out;
char addr[128] = { 0 };
prelude_string_new(&out);
if ( ((struct sockaddr *) &cnx->sa)->sa_family == AF_UNIX )
snprintf(addr, sizeof(addr), "unix");
else {
void *in_addr;
const char *str;
unsigned int port;
#ifdef HAVE_IPV6
port = ntohs(cnx->sa.sin6_port);
#else
port = ntohs(cnx->sa.sin_port);
#endif
in_addr = prelude_sockaddr_get_inaddr((struct sockaddr *) &cnx->sa);
if ( ! in_addr )
goto out;
str = inet_ntop(((struct sockaddr *)&cnx->sa)->sa_family, in_addr, addr, sizeof(addr));
if ( str )
snprintf(addr + strlen(addr), sizeof(addr) - strlen(addr), ":%u", port);
}
if ( cnx->ident && cnx->permission ) {
ret = prelude_string_sprintf(out, " 0x%" PRELUDE_PRIx64, cnx->ident);
if ( ret < 0 )
goto out;
ret = prelude_connection_permission_to_string(cnx->permission, out);
}
ret = prelude_string_sprintf(out, "]: ");
if ( ret < 0 )
goto out;
va_start(ap, fmt);
ret = prelude_string_vprintf(out, fmt, ap);
va_end(ap);
prelude_log(priority, "[%s%s", addr, prelude_string_get_string(out));
out:
prelude_string_destroy(out);
}
static prelude_string_t *get_message_ident(prelude_ident_t *ident)
{
int ret;
prelude_string_t *str;
ret = prelude_string_new(&str);
if ( ret < 0 )
return NULL;
ret = prelude_ident_generate(ident, str);
if ( ret < 0 ) {
prelude_string_destroy(str);
return NULL;
}
return str;
}
static void send_error(prelude_msgbuf_t *msgbuf, const char *fmt, ...)
{
int ret;
va_list ap;
prelude_string_t *out;
va_start(ap, fmt);
ret = prelude_string_new(&out);
if ( ret < 0 )
return;
prelude_string_vprintf(out, fmt, ap);
va_end(ap);
send_string(msgbuf, out, PRELUDE_MSG_OPTION_ERROR);
prelude_string_destroy(out);
}
static int default_table_name_resolver(const idmef_path_t *path, char **table_name)
{
char c;
int ret;
const char *class_name;
prelude_string_t *string;
prelude_bool_t next_is_maj = TRUE;
class_name = idmef_class_get_name(idmef_path_get_class(path, idmef_path_get_depth(path) - 2));
ret = prelude_string_new(&string);
if ( ret < 0 )
return ret;
ret = prelude_string_cat(string, "Prelude_");
if ( ret < 0 )
goto error;
while ( *class_name ) {
c = *class_name++;
if ( c == '_' ) {
next_is_maj = TRUE;
continue;
}
if ( next_is_maj ) {
c += 'A' - 'a';
next_is_maj = FALSE;
}
ret = prelude_string_ncat(string, &c, 1);
if ( ret < 0 )
goto error;
}
ret = prelude_string_get_string_released(string, table_name);
error:
prelude_string_destroy(string);
return ret;
}
/**
* idmef_message_set_string:
* @message: Pointer to an #idmef_message_t object.
* @path: Path to be set within @message.
* @value: Value to associate @message[@path] with.
*
* This function will set the @path member within @message to the
* provided @value, which will be converted to the corresponding
* @path value type.
*
* Example:
* idmef_message_set_string(message, "alert.classification.text", "MyText");
* idmef_message_set_string(message, "alert.source(0).service.port", "1024");
*
* Returns: 0 on success, or a negative value if an error occured.
*/
int idmef_message_set_string(idmef_message_t *message, const char *path, const char *value)
{
int ret;
idmef_value_t *iv;
prelude_string_t *str;
ret = prelude_string_new_dup(&str, value);
if ( ret < 0 )
return ret;
ret = idmef_value_new_string(&iv, str);
if ( ret < 0 ) {
prelude_string_destroy(str);
return ret;
}
ret = idmef_message_set_value(message, path, iv);
idmef_value_destroy(iv);
return ret;
}
static int value_resolve_variable(const char *ptr, char **out_p)
{
int ret;
size_t i;
char buf[512];
const char *tmp;
prelude_string_t *out;
ret = prelude_string_new(&out);
if ( ret < 0 )
return ret;
while ( *ptr ) {
if ( *ptr == '$' ) {
tmp = ptr;
i = 0;
do {
buf[i++] = *ptr++;
} while ( *ptr && *ptr != ' ' && *ptr != '$' && i < sizeof(buf) - 1);
buf[i] = 0;
if ( ! variable_get(buf + 1) )
ptr = tmp;
else {
prelude_string_cat(out, variable_get(buf + 1));
continue;
}
}
prelude_string_ncat(out, ptr, 1);
ptr++;
}
ret = prelude_string_get_string_released(out, out_p);
prelude_string_destroy(out);
return ret;
}
static int read_option_request(prelude_client_t *client, prelude_msgbuf_t *msgbuf, prelude_msg_t *msg)
{
void *buf;
uint8_t tag;
char *request;
uint32_t len, hop;
int ret, type = -1;
prelude_string_t *out;
while ( prelude_msg_get(msg, &tag, &len, &buf) == 0 ) {
switch (tag) {
case PRELUDE_MSG_OPTION_SET:
case PRELUDE_MSG_OPTION_GET:
case PRELUDE_MSG_OPTION_COMMIT:
case PRELUDE_MSG_OPTION_DESTROY:
type = tag;
break;
case PRELUDE_MSG_OPTION_HOP:
ret = prelude_extract_uint32_safe(&hop, buf, len);
if ( ret < 0 )
return ret;
hop = htonl(hop - 1);
prelude_msgbuf_set(msgbuf, tag, len, &hop);
break;
case PRELUDE_MSG_OPTION_TARGET_ID:
case PRELUDE_MSG_OPTION_TARGET_INSTANCE_ID:
case PRELUDE_MSG_OPTION_REQUEST_ID:
prelude_msgbuf_set(msgbuf, tag, len, buf);
break;
case PRELUDE_MSG_OPTION_LIST:
return prelude_option_wide_send_msg(msgbuf, client);
case PRELUDE_MSG_OPTION_VALUE:
ret = prelude_extract_characters_safe((const char **) &request, buf, len);
if ( ret < 0 )
return ret;
if ( type < 0 || ! request ) {
send_error(msgbuf, "No request specified");
return -1;
}
ret = prelude_string_new(&out);
if ( ret < 0 )
return ret;
ret = parse_request(client, type, request, out);
send_string(msgbuf, out, (ret < 0) ? PRELUDE_MSG_OPTION_ERROR : PRELUDE_MSG_OPTION_VALUE);
prelude_string_destroy(out);
break;
default:
send_error(msgbuf, "Unknown option tag: %d", tag);
return -1;
}
}
return 0;
}
