Example #1
0
/**
 * prelude_string_cat:
 * @dst: Pointer to a #prelude_string_t object.
 * @str: Pointer to a string.
 *
 * The prelude_string_cat() function appends the @str string to the @dst
 * prelude_string_t object over-writing the `\0' character at the end of
 * @dst, and then adds a termi-nating `\0' character.
 *
 * Returns: @len, or a negative value if an error occured.
 */
int prelude_string_cat(prelude_string_t *dst, const char *str)
{
        prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION));
        prelude_return_val_if_fail(str, prelude_error(PRELUDE_ERROR_ASSERTION));

        return prelude_string_ncat(dst, str, strlen(str));
}
Example #2
0
/**
 * prelude_string_cat:
 * @dst: Pointer to a #prelude_string_t object.
 * @str: Pointer to a string.
 * @len: Length of @str to copy.
 *
 * The prelude_string_ncat() function appends @len characters from @str to
 * the @dst #prelude_string_t object over-writing the `\0' character at the
 * end of @dst, and then adds a termi-nating `\0' character.
 *
 * Returns: @len, or a negative value if an error occured.
 */
int prelude_string_ncat(prelude_string_t *dst, const char *str, size_t len)
{
        int ret;

        prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION));
        prelude_return_val_if_fail(str, prelude_error(PRELUDE_ERROR_ASSERTION));

        if ( dst->flags & PRELUDE_STRING_OWN_DATA && len < (dst->size - dst->index) ) {

                memcpy(dst->data.rwbuf + dst->index, str, len);

                dst->index += len;
                dst->data.rwbuf[dst->index] = '\0';

                return len;
        }

        if ( len + 1 < len )
                return prelude_error(PRELUDE_ERROR_INVAL_LENGTH);

        ret = allocate_more_chunk_if_needed(dst, len + 1);
        if ( ret < 0 )
                return ret;

        return prelude_string_ncat(dst, str, len);
}
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;
}
Example #4
0
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;
}